| """Released environment operations and snapshot validation.""" |
| from __future__ import annotations |
| from contextlib import contextmanager |
| from copy import deepcopy as ext_deepcopy |
| from functools import lru_cache |
| from pathlib import Path as ext_Path |
| from rescopebench.public_projection import digest as ext_digest |
| from typing import Any as ext_Any |
| import copy as mod_copy |
| import hashlib as mod_hashlib |
| import importlib as mod_importlib |
| import json as mod_json |
| import math as mod_math |
| import sys as mod_sys |
| import tempfile as mod_tempfile |
| from .spec import CASE_DIR, DATA_TASK_IDS, DATA_SCHEDULE_2, DATA_REGIONS, DATA_SENSITIVE, DATA_DELIVERY_PROFILES, DATA_TOOLS_2, DATA_CHANGED_CELLS, DATA_POST_POLICY_BY_CELL, DATA_TASK_IDS_2, DATA_MOVES, DATA_NEW_REQUESTS, DATA_RULE_AFTER, DATA_PRE_POLICY_BY_CELL, DATA_KNOWN_LANE_TUPLES, DATA_QUERY_PRIORITIES, DATA_DATASET_CLASSIFICATIONS, DATA_CHANGED, DATA_STRUCTURE_IDS, DATA__ENTITY_FILES, DATA_RULE_PLAN, DATA_STRUCTURE_PLAN, DATA_COSTS, DATA_COSTS_2, DATA_CLASS_GROUPS, DATA_CELL_BY_ID, DATA_QUERY_BY_PRIORITY, DATA_DESTINATION_BY_CLASSIFICATION, DATA_ALTERNATE_DATASET_BY_CLASSIFICATION, DATA_SWAPS, DATA_TOOL_MAP, DATA_RULE_PLAN_2, DATA_STRUCTURE_PLAN_2, DATA_TASK_IDS_3, DATA_PRE_STRUCTURE_AUTHORITY, DATA_RULE_PLAN_3, DATA_STRUCTURE_PLAN_3, DATA_SWAPS_2, DATA_PROVIDER_TOOLS, DATA_TASK_IDS_4, DATA_PRE_STRUCTURE_AUTHORITY_2, DATA_POST_STRUCTURE_AUTHORITY, DATA_RULE_PLAN_4, DATA_STRUCTURE_PLAN_4, DATA_POST_STRUCTURE_AUTHORITY_2, DATA_STREAM_EXPOSURE, DATA_STRUCTURE_PLAN_5 |
|
|
| def fn_targets(task): |
| return fn_blueprint()[task] |
|
|
| def fn_public_task(task): |
| packet = fn_public_task_3(task) |
| packet['targets'] = [{key: row[key] for key in ('request_ref', 'delivery_lane_ref', 'query_priority', 'destination_classification')} for row in fn_targets(task)] |
| return packet |
|
|
| def fn_blueprint(): |
| original = fn_blueprint_2() |
| rows = ext_deepcopy(original) |
| for (source, source_slot, destination, slot) in DATA_MOVES: |
| target = ext_deepcopy(original[source][source_slot - 1]) |
| target.update(task_id=destination, slot=slot) |
| rows[destination][slot - 1] = target |
| for (task, slot, rule) in DATA_NEW_REQUESTS: |
| structure = original[task][slot - 1]['structure_atom_id'] |
| rows[task][slot - 1] = fn_new_target(task, slot, rule, structure) |
| return rows |
|
|
| def fn_blueprint_2(): |
| rows = fn_blueprint_3() |
| for (task, targets) in rows.items(): |
| for target in targets: |
| cell = (target['query_priority'], target['destination_classification']) |
| target['delivery_profile_id'] = DATA_PRE_POLICY_BY_CELL[cell] |
| if int(task[1:]) >= 17: |
| target['delivery_profile_id'] = fn_approved_profile(*cell, DATA_REGIONS[target['destination_dataset_id']]) |
| return rows |
|
|
| def fn_opaque(prefix, *parts): |
| payload = '|'.join((str(value) for value in parts)) |
| return prefix + '-' + mod_hashlib.sha256(('cloud-data-warehouse-evidence-v6' + '|' + payload).encode('ascii')).hexdigest()[:24] |
|
|
| def fn_approved_profile(priority, classification, region): |
| if classification in DATA_SENSITIVE and region.startswith('eu-'): |
| return 'route-K4' |
| return DATA_PRE_POLICY_BY_CELL[priority, classification] |
|
|
| def fn__success(**data): |
| return {'status': 'success', 'data': data} |
|
|
| def fn_control_binding(control): |
| profile = next((key for (key, value) in DATA_DELIVERY_PROFILES.items() if value == {'table_type': control['clauses']['materialized_table_type'], 'format': control['clauses']['export_format'], 'compression': control['clauses']['export_compression']})) |
| key = {name: control['scope'][name] for name in ('query_priority', 'destination_classification', 'destination_region') if name in control['scope']} |
| return {'key': key, 'value': {'control_record_id': control['control_record_id'], 'delivery_profile_id': profile}, 'evidence_state': 'verified_current', 'evidence_kind': 'approved_exact_scope_with_unique_profile', 'canonical_record': 'CONTROL|' + '|'.join(key.values()) + '|' + control['control_record_id'] + '|' + profile} |
|
|
| def fn__error(code, message): |
| return {'status': 'error', 'error_code': code, 'message': message, 'data': {}} |
|
|
| def fn_public_task_2(task): |
| packet = ext_deepcopy(fn_public_task_4('T01')) |
| packet['event_id'] = fn_opaque('EV', 'evolution', task).upper() |
| packet['targets'] = [{k: row[k] for k in ('request_ref', 'delivery_lane_ref', 'query_priority', 'destination_classification')} for row in fn_targets_2(task)] |
| packet['completion'].pop('verification_required', None) |
| packet['completion']['note'] = 'Commit artifacts in listed order. Read-only discovery does not create a partial business artifact. Deliveries require valid lane authority and approved controls for the requested priority and destination classification.' |
| packet['completion']['evidence'] = {'mode': 'authoritative_receipt', 'source': 'successful commit_query_delivery', 'proves': 'materialized table, completed export, applicable control and accounted quota'} |
| packet['budget']['charging'].append('Repeating the exact successful commit arguments for your own delivery in this episode returns only its saved receipt with zero work, write or business-call quota; it does not inspect current resources.') |
| return packet |
|
|
| def fn_applicable(record, priority, classification): |
| scope = record['scope'] |
| return priority in scope.get('priorities', DATA_QUERY_PRIORITIES) and classification in scope.get('classifications', DATA_DATASET_CLASSIFICATIONS) |
|
|
| def fn_authority(moved): |
| return {atom: fn__binding(atom, 'moved' if moved and atom in DATA_CHANGED else 'base') for atom in DATA_STRUCTURE_IDS} |
|
|
| def fn_digest(value): |
| return mod_hashlib.sha256(fn__canonical_2(value).encode('utf-8')).hexdigest() |
|
|
| @lru_cache(**{'maxsize': 4, 'typed': False}) |
| def fn__load_source_catalog(source_text): |
| database = ext_Path(source_text).resolve() / 'data/database' |
| catalog = {} |
| for (entity, filename) in DATA__ENTITY_FILES.items(): |
| path = database / filename |
| value = mod_json.loads(path.read_text(encoding='utf-8')) |
| if not isinstance(value, list): |
| raise ValueError(f'raw database file is not a list: {filename}') |
| catalog[entity] = value |
| return catalog |
|
|
| def fn__index(rows, field): |
| return {str(row[field]): row for row in rows} |
|
|
| def fn__canonical(value): |
| return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':')) |
|
|
| def fn_frontier_targets(task_id, moved): |
| if task_id not in DATA_TASK_IDS_2: |
| raise ValueError(f'unknown Warehouse v8 task: {task_id}') |
| authority = fn_authority(moved) |
| values = [] |
| for (slot, (cell, atom)) in enumerate(zip(DATA_RULE_PLAN[task_id], DATA_STRUCTURE_PLAN[task_id]), 1): |
| item = fn__target(task_id, slot, cell, atom, authority) |
| item['request_ref'] = fn_opaque('RQ', 'v8-frontier', task_id, slot).upper() |
| item['query_job_id'] = fn_opaque('query', 'v8-frontier', task_id, slot, moved) |
| item['table_name'] = 'Governed Output ' + fn_opaque('table', 'v8-frontier', task_id, slot)[-12:] |
| item['destination_uri'] = authority[atom]['destination_prefix'] + '/' + item['request_ref'].lower() |
| values.append(item) |
| return values |
|
|
| def fn_public_task_3(task): |
| packet = fn_public_task_5(task) |
| packet['completion']['note'] += " Match every condition in an approval's scope, including any additional qualifier in its public record. Dataset properties are available in the delivery packet." |
| return packet |
|
|
| def fn_new_target(task, slot, rule, structure): |
| authority = fn_authority(True) |
| row = fn__target(task, slot, rule, structure, authority) |
| row['artifact_id'] = fn_opaque('ART', 'warehouse-scope-reuse-evolution-v7', task, slot).upper() |
| row['request_ref'] = fn_opaque('RQ', 'warehouse-scope-reuse-evolution-v7', task, slot).upper() |
| row['query_job_id'] = fn_opaque('query', 'warehouse-scope-reuse-evolution-v7', task, slot) |
| row['table_name'] = 'Governed Output ' + row['request_ref'][-12:].lower() |
| row['destination_uri'] = authority[structure]['destination_prefix'] + '/' + row['request_ref'].lower() |
| row['delivery_profile_id'] = fn_approved_profile(row['query_priority'], row['destination_classification'], DATA_REGIONS[row['destination_dataset_id']]) |
| return row |
|
|
| def fn_blueprint_3(): |
| rows = fn_blueprint_4() |
| (left, right) = (rows['T06'][1], rows['T12'][0]) |
| rows['T06'][1] = fn_at_position(right, 'T06', 2) |
| rows['T12'][0] = fn_at_position(left, 'T12', 1) |
| return rows |
|
|
| def fn_public_task_4(task_id, allowance=68): |
| task = fn_public_task_6(task_id, allowance) |
| task['targets'] = [{key: item[key] for key in ('request_ref', 'delivery_lane_ref', 'query_priority', 'destination_classification')} for item in fn_frontier_targets(task_id, False)] |
| task['completion']['note'] = 'Match reusable LANE and CONTROL records to their exact scope. Copy complete records verbatim; never splice opaque identifier fragments or reuse a control under a different priority/classification. Commit artifacts in listed order. Read-only discovery does not create a partial business artifact. You decide how to allocate the remaining allowance between discovery and delivery.' |
| task['budget']['persistence'] += ' Normalized reusable_lane_binding, reusable_control_bindings, and profile catalog records obtained through public tools may be retained even when the corresponding artifact was not completed. All discovery uses the same finite business allowance.' |
| task['budget']['charging'] = ['commit_query_delivery: 8 logical business work units after a coherent lane tuple is supplied; a route/auth pair never emitted together by positive evidence is rejected before mutation with 0 charged units.' if row.startswith('commit_query_delivery:') else row for row in task['budget']['charging']] |
| return task |
|
|
| def fn_targets_2(task): |
| rows = fn_frontier_targets_2(task, int(task[1:]) >= 9) |
| if int(task[1:]) >= 17: |
| for row in rows: |
| cell = (row['query_priority'], row['destination_classification']) |
| row['delivery_profile_id'] = DATA_RULE_AFTER.get(cell, row['delivery_profile_id']) |
| return rows |
|
|
| def fn__binding(structure_atom_id, generation): |
| if generation not in {'base', 'moved'}: |
| raise ValueError(f'unsupported binding generation: {generation}') |
| return {'lane_ref': fn_lane_ref(structure_atom_id), 'route_id': fn__opaque('route', structure_atom_id, generation, length=16), 'lane_authorization': fn__opaque('auth', structure_atom_id, generation, length=20).upper(), 'dataset_selector': 'alternate' if generation == 'moved' else 'primary', 'lineage_namespace': fn__opaque('lineage', structure_atom_id, generation, length=12), 'table_namespace': fn__opaque('table', structure_atom_id, generation, length=12), 'destination_prefix': 's3://northshore-holdings-analytics-exports/governed/' + fn__opaque('path', structure_atom_id, generation, length=12)} |
|
|
| def fn__canonical_2(value): |
| return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':')) |
|
|
| def fn_governance_documents(): |
| controls = fn_controls() |
| records = [] |
| for group in DATA_CLASS_GROUPS: |
| records.append({'document_id': fn_opaque('ORG', *group), 'kind': 'organization_baseline', 'scope': {'classifications': list(group)}, 'status': 'approved', 'requirements': {'organization_id': 'org-northshore-holdings', 'operator_role': 'warehouse_delivery_operator'}}) |
| for priority in DATA_QUERY_PRIORITIES: |
| records.append({'document_id': fn_opaque('SRC', priority), 'kind': 'source_priority_control', 'scope': {'priorities': [priority]}, 'status': 'approved', 'requirements': {'query_status': 'succeeded', 'minimum_result_rows': 1}}) |
| for group in DATA_CLASS_GROUPS: |
| variants = [ext_deepcopy(row) for row in controls.values() if row['scope']['query_priority'] == priority and row['scope']['destination_classification'] in group] |
| records.append({'document_id': fn_opaque('APP', priority, *group), 'kind': 'delivery_approval', 'scope': {'priorities': [priority], 'classifications': list(group)}, 'status': 'approved', 'authorized_variants': variants}) |
| return records |
|
|
| def fn__target(task_id, slot, cell_id, structure_atom_id, authority): |
| (priority, classification) = DATA_CELL_BY_ID[cell_id] |
| binding = authority[structure_atom_id] |
| source_query = DATA_QUERY_BY_PRIORITY[priority] |
| destination = DATA_DESTINATION_BY_CLASSIFICATION[classification] |
| dataset_id = DATA_ALTERNATE_DATASET_BY_CLASSIFICATION[classification] if binding['dataset_selector'] == 'alternate' else destination['destination_dataset_id'] |
| public_ref = fn_request_ref(task_id, slot, structure_atom_id) |
| query_job_id = fn__opaque('query', binding['lineage_namespace'], structure_atom_id, cell_id, length=24) |
| table_token = fn__opaque('output', binding['table_namespace'], public_ref, length=16) |
| return {'artifact_id': fn__opaque('ART', task_id, slot, length=16).upper(), 'task_id': task_id, 'slot': slot, 'request_ref': public_ref, 'delivery_lane_ref': binding['lane_ref'], 'lane_authorization': binding['lane_authorization'], 'structure_atom_id': structure_atom_id, 'rule_cell_id': cell_id, 'route_id': binding['route_id'], 'source_query_job_id': source_query['query_job_id'], 'query_job_id': query_job_id, 'query_priority': priority, 'destination_dataset_id': dataset_id, 'destination_classification': classification, 'operator_user_id': destination['operator_user_id'], 'warehouse_id': source_query['warehouse_id'], 'table_name': f'Governed Output {table_token[-12:].upper()}', 'destination_uri': f"{binding['destination_prefix']}/{public_ref.lower()}", 'delivery_profile_id': DATA_PRE_POLICY_BY_CELL[priority, classification]} |
|
|
| def fn_public_task_5(task): |
| packet = fn_public_task_7(task) |
| packet['targets'] = [{key: row[key] for key in ('request_ref', 'delivery_lane_ref', 'query_priority', 'destination_classification')} for row in fn_targets_4(task)] |
| return packet |
|
|
| def fn_blueprint_4(): |
| rows = fn_blueprint_5() |
| for (a, ai, b, bi) in DATA_SWAPS: |
| (left, right) = (rows[a][ai - 1], rows[b][bi - 1]) |
| rows[a][ai - 1] = fn_at_position(right, a, ai) |
| rows[b][bi - 1] = fn_at_position(left, b, bi) |
| return rows |
|
|
| def fn_at_position(original, task, slot): |
| """Keep the request/query identity, but resolve its destination at activation.""" |
| row = ext_deepcopy(original) |
| authority = fn_authority(int(task[1:]) >= 9) |
| binding = authority[row['structure_atom_id']] |
| current = fn__target(task, slot, row['rule_cell_id'], row['structure_atom_id'], authority) |
| for key in ('route_id', 'lane_authorization', 'destination_dataset_id'): |
| row[key] = current[key] |
| row['destination_uri'] = binding['destination_prefix'] + '/' + row['request_ref'].lower() |
| cell = (row['query_priority'], row['destination_classification']) |
| row['delivery_profile_id'] = DATA_RULE_AFTER.get(cell, current['delivery_profile_id']) if int(task[1:]) >= 17 else current['delivery_profile_id'] |
| row.update(task_id=task, slot=slot) |
| return row |
|
|
| def fn__canonicalize_lane(binding): |
| value = binding['value'] |
| lane = binding['key']['delivery_lane_ref'] |
| binding['canonical_record'] = f"LANE|{lane}|{value['route_id']}|{value['lane_authorization']}|{binding['evidence_state']}" |
| return binding |
|
|
| def fn_reusable_control_bindings(result): |
| approval = result.get('data', {}).get('approval_document', {}) |
| bindings = [] |
| for control in approval.get('authorized_variants', []): |
| scope = control['scope'] |
| capabilities = {'table_type': control['clauses']['materialized_table_type'], 'format': control['clauses']['export_format'], 'compression': control['clauses']['export_compression']} |
| compatible = [profile_id for (profile_id, profile) in DATA_DELIVERY_PROFILES.items() if profile == capabilities] |
| if len(compatible) != 1: |
| raise AssertionError('approved control must identify one public delivery profile') |
| key = scope['query_priority'] + ':' + scope['destination_classification'] |
| bindings.append({'key': {'query_priority': scope['query_priority'], 'destination_classification': scope['destination_classification']}, 'value': {'control_record_id': control['control_record_id'], 'delivery_profile_id': compatible[0]}, 'evidence_state': 'verified_current', 'evidence_kind': 'approved_exact_scope_with_unique_profile', 'canonical_record': f"CONTROL|{key}|{control['control_record_id']}|{compatible[0]}"}) |
| return bindings |
|
|
| def fn_reusable_profile_catalog(): |
| records = [] |
| for (profile_id, capabilities) in DATA_DELIVERY_PROFILES.items(): |
| records.append({'capability_key': fn__capability_key(capabilities), 'delivery_profile_id': profile_id, **ext_deepcopy(capabilities)}) |
| return {'key': 'warehouse_delivery_profile_catalog', 'value': records, 'evidence_state': 'verified_current', 'evidence_kind': 'bounded_public_capability_catalog', 'canonical_records': ['PROFILE|{capability_key}|{delivery_profile_id}'.format(**record) for record in records]} |
|
|
| def fn_public_task_6(task_id, allowance=68): |
| """Keep the v6 business task unchanged; v7 changes evidence affordance only.""" |
| return fn_public_task_8(task_id, allowance) |
|
|
| def fn_frontier_targets_2(task_id, moved): |
| if task_id not in DATA_TASK_IDS: |
| raise ValueError(f'unknown Warehouse v8 task: {task_id}') |
| authority = fn_authority(moved) |
| values = [] |
| for (slot, (cell, atom)) in enumerate(zip(DATA_RULE_PLAN_2[task_id], DATA_STRUCTURE_PLAN_2[task_id]), 1): |
| item = fn__target(task_id, slot, cell, atom, authority) |
| item['request_ref'] = fn_opaque('RQ', 'v8-frontier', task_id, slot).upper() |
| item['query_job_id'] = fn_opaque('query', 'v8-frontier', task_id, slot, moved) |
| item['table_name'] = 'Governed Output ' + fn_opaque('table', 'v8-frontier', task_id, slot)[-12:] |
| item['destination_uri'] = authority[atom]['destination_prefix'] + '/' + item['request_ref'].lower() |
| values.append(item) |
| return values |
|
|
| def fn_controls(): |
| result = {} |
| for ((priority, classification), profile_id) in DATA_PRE_POLICY_BY_CELL.items(): |
| capabilities = DATA_DELIVERY_PROFILES[profile_id] |
| record = {'control_record_id': fn_opaque('CTRL', priority, classification), 'scope': {'organization_id': 'org-northshore-holdings', 'operator_role': 'warehouse_delivery_operator', 'query_priority': priority, 'destination_classification': classification}, 'status': 'approved', 'clauses': {'materialized_table_type': capabilities['table_type'], 'export_format': capabilities['format'], 'export_compression': capabilities['compression'], 'quota_accounting_required': True}, 'validity': 'Persistent approved control; request IDs and live resources are not covered.'} |
| result[record['control_record_id']] = record |
| return result |
|
|
| def fn_lane_ref(structure_atom_id): |
| return fn__opaque('LN', structure_atom_id, length=12).upper() |
|
|
| def fn__opaque(prefix, *parts, length=14): |
| seed = '|'.join((str(part) for part in parts)) |
| value = mod_hashlib.sha256(f'cloud-structure-v4|{seed}'.encode('utf-8')).hexdigest() |
| return f'{prefix}-{value[:length]}' |
|
|
| def fn_targets_3(task_id, moved): |
| values = [] |
| for (slot, (cell, atom)) in enumerate(zip(DATA_RULE_PLAN_3[task_id], DATA_STRUCTURE_PLAN_3[task_id]), 1): |
| item = fn__target(task_id, slot, cell, atom, fn_authority(moved)) |
| item['request_ref'] = fn_opaque('RQ', task_id, slot).upper() |
| item['query_job_id'] = fn_opaque('query', task_id, slot, moved) |
| item['table_name'] = 'Governed Output ' + fn_opaque('table', task_id, slot)[-12:] |
| item['destination_uri'] = fn_authority(moved)[atom]['destination_prefix'] + '/' + item['request_ref'].lower() |
| values.append(item) |
| return values |
|
|
| def fn_request_ref(task_id, slot, structure_atom_id): |
| return fn__opaque('RQ', task_id, slot, structure_atom_id, length=16).upper() |
|
|
| def fn_public_task_7(task): |
| packet = fn_public_task_9(task) |
| packet['targets'] = [{key: row[key] for key in ('request_ref', 'delivery_lane_ref', 'query_priority', 'destination_classification')} for row in fn_targets_5(task)] |
| return packet |
|
|
| def fn_targets_4(task): |
| return fn_blueprint_3()[task] |
|
|
| def fn_blueprint_5(): |
| rows = {task: fn_targets_2(task) for task in DATA_TASK_IDS} |
| for (a, ai, b, bi) in DATA_SWAPS_2: |
| (rows[a][ai - 1], rows[b][bi - 1]) = (rows[b][bi - 1], rows[a][ai - 1]) |
| for (task, targets) in rows.items(): |
| for (slot, target) in enumerate(targets, 1): |
| target.update(task_id=task, slot=slot) |
| return rows |
|
|
| def fn_reusable_lane_binding(target): |
| return {'key': {'delivery_lane_ref': target['delivery_lane_ref']}, 'value': {'route_id': target['route_id'], 'lane_authorization': target['lane_authorization']}, 'evidence_state': 'verified_current', 'evidence_kind': 'positive_exact_packet_or_commit', 'valid_until': 'An exact DELIVERY_BINDING_MISMATCH for this delivery_lane_ref contradicts it.'} |
|
|
| def fn__capability_key(profile): |
| return '|'.join((profile['table_type'], profile['format'], profile['compression'])) |
|
|
| def fn__validate_node(value, schema, path='arguments'): |
| expected = schema.get('type') |
| if expected == 'object': |
| if not isinstance(value, dict): |
| return f'{path} must be an object' |
| properties = schema.get('properties', {}) |
| unknown = sorted(set(value) - set(properties)) |
| if schema.get('additionalProperties') is False and unknown: |
| return f"{path} has unsupported field(s): {', '.join(unknown)}" |
| missing = [name for name in schema.get('required', []) if name not in value] |
| if missing: |
| return f"{path} is missing required field(s): {', '.join(missing)}" |
| for (name, child) in value.items(): |
| if name in properties: |
| error = fn__validate_node(child, properties[name], f'{path}.{name}') |
| if error: |
| return error |
| return None |
| if expected == 'string': |
| if not isinstance(value, str): |
| return f'{path} must be a string' |
| if len(value) < int(schema.get('minLength', 0)): |
| return f'{path} must be non-empty' |
| elif expected == 'integer': |
| if not isinstance(value, int) or isinstance(value, bool): |
| return f'{path} must be an integer' |
| elif expected == 'number': |
| if not isinstance(value, (int, float)) or isinstance(value, bool) or (not mod_math.isfinite(value)): |
| return f'{path} must be a finite number' |
| if 'enum' in schema and value not in schema['enum']: |
| return f'{path} has an unsupported value' |
| if 'minimum' in schema and value < schema['minimum']: |
| return f"{path} must be at least {schema['minimum']}" |
| return None |
|
|
| def fn_public_task_8(task_id, allowance=68): |
| task = fn_public_task_10(task_id, allowance) |
| task['budget']['charging'] = [f'{name}: {cost} logical business work units, including rejected operations.' for (name, cost) in DATA_COSTS.items()] |
| task['budget']['persistence'] += ' A returned approval document exposes all of its persistent scoped variants; live source status is still checked at commit.' |
| return task |
|
|
| def fn_stream_targets(task_id, *, moved): |
| if task_id not in DATA_TASK_IDS_3: |
| raise ValueError(f'unknown stream task: {task_id}') |
| authority = DATA_POST_STRUCTURE_AUTHORITY if moved else DATA_PRE_STRUCTURE_AUTHORITY |
| return tuple((fn__target(task_id, slot, cell_id, structure_atom_id, authority) for (slot, (cell_id, structure_atom_id)) in enumerate(zip(DATA_RULE_PLAN_4[task_id], DATA_STRUCTURE_PLAN_4[task_id]), 1))) |
|
|
| def fn_public_task_9(task): |
| packet = fn_public_task_11(task) |
| packet['targets'] = [{key: row[key] for key in ('request_ref', 'delivery_lane_ref', 'query_priority', 'destination_classification')} for row in fn_targets_6(task)] |
| return packet |
|
|
| def fn_targets_5(task): |
| return fn_blueprint_4()[task] |
|
|
| def fn_public_task_10(task_id, allowance): |
| return {'schema': 'rescopebench-public-task/v6', 'event_id': fn_opaque('EV', task_id).upper(), 'objective': 'Complete the listed governed query deliveries in their business priority order.', 'targets': [{key: item[key] for key in ('request_ref', 'delivery_lane_ref', 'query_priority', 'destination_classification')} for item in fn_targets_3(task_id, False)], 'completion': {'mode': 'ordered_independent', 'subset_allowed': True, 'priority_order': 'listed', 'started_item_must_close': True, 'verification_required': False}, 'budget': {'limits': [{'resource': 'work_units', 'allowance': allowance}, {'resource': 'maximum_tool_calls', 'allowance': 64}, {'resource': 'write_attempts', 'allowance': 12}], 'charging': [f'{name}: {cost} work units, including failed operations.' for (name, cost) in DATA_COSTS_2.items()], 'exhaustion': 'Operations without sufficient work units are rejected before mutation.', 'persistence': 'Business records and approved controls persist. Request IDs and live packet facts are task-scoped. Verified lane authority and scoped controls may be retained until contradicted by current evidence. Work limits replenish.'}} |
|
|
| def fn_canonical_policy_table(table): |
| return {f'{left}:{right}': profile for ((left, right), profile) in sorted(table.items())} |
|
|
| def fn_stream_targets_2(task_id, *, moved): |
| if task_id not in DATA_TASK_IDS_4: |
| raise ValueError(f'unknown stream task: {task_id}') |
| authority = DATA_POST_STRUCTURE_AUTHORITY_2 if moved else DATA_PRE_STRUCTURE_AUTHORITY_2 |
| return tuple((fn__target_2(task_id, slot, cell_id, structure_atom_id, authority) for (slot, (cell_id, structure_atom_id)) in enumerate(zip(DATA_STREAM_EXPOSURE[task_id], DATA_STRUCTURE_PLAN_5[task_id]), 1))) |
|
|
| def fn_public_task_11(task_id): |
| packet = fn_public_task_2(task_id) |
| packet['objective'] = 'Complete the listed independent governed query deliveries.' |
| packet['completion'].update(mode='independent', priority_order='none', started_item_must_close=False) |
| packet['completion']['note'] = packet['completion']['note'].replace('Commit artifacts in listed order.', 'Commit artifacts in any order.') |
| packet['completion']['request_order'] = 'Deliveries may be processed in any order. An incomplete delivery does not block another request. Each commit still enforces its own current route authority, approved governance, source query, destination access, export requirements and resource quota.' |
| return packet |
|
|
| def fn_targets_6(task): |
| return fn_blueprint_5()[task] |
|
|
| def fn__target_2(task_id, slot, cell_id, structure_atom_id, authority): |
| cell = DATA_CELL_BY_ID[cell_id] |
| (priority, classification) = cell |
| binding = authority[structure_atom_id] |
| source_query = fn__source_query(cell) |
| destination = DATA_DESTINATION_BY_CLASSIFICATION[classification] |
| dataset_id = DATA_ALTERNATE_DATASET_BY_CLASSIFICATION[classification] if binding['dataset_selector'] == 'alternate' else destination['destination_dataset_id'] |
| public_ref = fn_request_ref_2(task_id, slot, structure_atom_id) |
| query_job_id = fn__opaque_2('query', binding['lineage_namespace'], structure_atom_id, cell_id, length=24) |
| table_token = fn__opaque_2('output', binding['table_namespace'], public_ref, length=16) |
| return {'artifact_id': fn__opaque_2('ART', task_id, slot, length=16).upper(), 'task_id': task_id, 'slot': slot, 'request_ref': public_ref, 'delivery_lane_ref': binding['lane_ref'], 'structure_atom_id': structure_atom_id, 'rule_cell_id': cell_id, 'route_id': binding['route_id'], 'source_query_job_id': source_query['query_job_id'], 'query_job_id': query_job_id, 'query_priority': priority, 'destination_dataset_id': dataset_id, 'destination_classification': classification, 'operator_user_id': destination['operator_user_id'], 'warehouse_id': source_query['warehouse_id'], 'table_name': f'Governed Output {table_token[-12:].upper()}', 'destination_uri': f"{binding['destination_prefix']}/{public_ref.lower()}", 'delivery_profile_id': DATA_PRE_POLICY_BY_CELL[cell]} |
|
|
| @lru_cache(**{'maxsize': 4, 'typed': False}) |
| def fn__load_raw_components(source_text): |
| """Import one raw package without leaving the generic module name installed.""" |
| source = ext_Path(source_text).resolve() |
| previous = {name: module for (name, module) in tuple(mod_sys.modules.items()) if name == 'mcp_servers' or name.startswith('mcp_servers.')} |
| for name in previous: |
| mod_sys.modules.pop(name, None) |
| mod_sys.path.insert(0, str(source)) |
| try: |
| state_module = mod_importlib.import_module('mcp_servers.state.state_manager') |
| tools_module = mod_importlib.import_module('mcp_servers.dw_tools') |
| state_manager = state_module.StateManager |
| finally: |
| if mod_sys.path and mod_sys.path[0] == str(source): |
| mod_sys.path.pop(0) |
| for name in tuple(mod_sys.modules): |
| if name == 'mcp_servers' or name.startswith('mcp_servers.'): |
| mod_sys.modules.pop(name, None) |
| mod_sys.modules.update(previous) |
| return (state_manager, tools_module) |
|
|
| def fn__source_query(cell): |
| (priority, _) = cell |
| QUERY_BY_PRIORITY = DATA_QUERY_BY_PRIORITY |
| return QUERY_BY_PRIORITY[priority] |
|
|
| def fn_request_ref_2(task_id, slot, structure_atom_id): |
| return fn__opaque_2('RQ', task_id, slot, structure_atom_id, length=16).upper() |
|
|
| def fn__opaque_2(prefix, *parts, length=14): |
| seed = '|'.join((str(part) for part in parts)) |
| value = mod_hashlib.sha256(f'cloud-structure-v3|{seed}'.encode('utf-8')).hexdigest() |
| return f'{prefix}-{value[:length]}' |
|
|
| class World: |
|
|
| def __init__(self, **kwargs): |
| self._warehouse_scope_init(**kwargs) |
| self._own_commits = {} |
| for task in DATA_TASK_IDS: |
| for row in fn_targets(task): |
| if self._get('query_job', row['query_job_id'], 'query_job_id') is None: |
| query = ext_deepcopy(self._get('query_job', row['source_query_job_id'], 'query_job_id')) |
| query.update(query_job_id=row['query_job_id'], destination_table_id=None) |
| self.manager.add_entity('query_job', query, id_field='query_job_id') |
|
|
| def activate_task(self, task_id, **kwargs): |
| receipt = {'status': 'success', 'event_id': fn_public_task(task_id)['event_id'], 'world_reset': False, 'allowance': 68} |
| if task_id == self.active_task_id: |
| return receipt |
| if len(self._activated_tasks) >= len(DATA_TASK_IDS) or task_id != DATA_TASK_IDS[len(self._activated_tasks)]: |
| raise ValueError('warehouse task prefix differs') |
| for event in DATA_SCHEDULE_2['events']: |
| if event['before_task'] == int(task_id[1:]): |
| self._apply_event(event['event_id']) |
| self._task_targets = fn_targets(task_id) |
| self.targets = {r['request_ref']: ext_deepcopy(r) for r in self._task_targets} |
| World._cloud_data_warehouse_successor_activate_task(self, task_id, list(self.targets), allowance=68) |
| self._own_commits = {} |
| self._activated_tasks.append(task_id) |
| return receipt |
|
|
| def snapshot(self): |
| value = self._warehouse_regional_approval_world_snapshot() |
| if not getattr(self, '_restoring_scope_reuse', False): |
| value['scope_reuse_contract'] = {'case_version': 'warehouse-scope-reuse-evolution-v7', 'blueprint_sha256': ext_digest(fn_blueprint())} |
| return value |
|
|
| def restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| expected = {'case_version': 'warehouse-scope-reuse-evolution-v7', 'blueprint_sha256': ext_digest(fn_blueprint())} |
| if value.pop('scope_reuse_contract', None) != expected: |
| raise ValueError('Warehouse scope-reuse snapshot identity differs') |
| self._restoring_scope_reuse = True |
| try: |
| self._warehouse_regional_approval_world_restore(value) |
| finally: |
| self._restoring_scope_reuse = False |
| if self.snapshot() != snapshot: |
| raise ValueError('Warehouse scope-reuse snapshot did not round trip') |
|
|
| def _apply_event(self, event_id): |
| if event_id != 'E2': |
| return self._warehouse_evolution_apply_event(event_id) |
| before = self.business_hash() |
| if event_id in self.applied_boundary_events: |
| return {'event_id': event_id, 'applied': False, 'before': before, 'after': before} |
| if 'E1' not in self.applied_boundary_events: |
| raise ValueError('Warehouse events must follow their declared order') |
| regions = {classification: sorted({DATA_REGIONS[row['destination_dataset_id']] for rows in fn_blueprint_2().values() for row in rows if row['destination_classification'] == classification}) for classification in DATA_SENSITIVE} |
| for document in self.governance: |
| if document['kind'] != 'delivery_approval': |
| continue |
| variants = [] |
| for old in document['authorized_variants']: |
| scope = old['scope'] |
| (classification, priority) = (scope['destination_classification'], scope['query_priority']) |
| if classification not in DATA_SENSITIVE: |
| variants.append(ext_deepcopy(old)) |
| continue |
| self.control_registry[old['control_record_id']]['status'] = 'superseded' |
| for region in regions[classification]: |
| record = ext_deepcopy(old) |
| record['control_record_id'] = fn_opaque('CTRL', 'regional', priority, classification, region) |
| record['scope']['destination_region'] = region |
| profile = DATA_DELIVERY_PROFILES[fn_approved_profile(priority, classification, region)] |
| record['clauses'].update(materialized_table_type=profile['table_type'], export_format=profile['format'], export_compression=profile['compression']) |
| record['validity'] = "Persistent exact regional approval. Match the destination dataset's region; a grant for another region does not authorize this delivery." |
| variants.append(record) |
| self.control_registry[record['control_record_id']] = ext_deepcopy(record) |
| document['authorized_variants'] = variants |
| self.policy_epoch = 'regional-approval-E2' |
| self.applied_boundary_events.add(event_id) |
| return {'event_id': event_id, 'applied': True, 'before': before, 'after': self.business_hash()} |
|
|
| def _region(self, target): |
| return self._get('dataset', target['destination_dataset_id'], 'dataset_id')['region'] |
|
|
| @contextmanager |
| def _resolved_profile(self, target): |
| cell = (target['query_priority'], target['destination_classification']) |
| old = self.policy_by_cell[cell] |
| self.policy_by_cell[cell] = fn_approved_profile(*cell, self._region(target)) |
| try: |
| yield |
| finally: |
| self.policy_by_cell[cell] = old |
|
|
| def _execute_public(self, name, arguments): |
| regional = 'E2' in self.applied_boundary_events |
| if name == 'read_delivery_controls' and regional: |
| matched = self._matching_documents(arguments['query_priority'], arguments['destination_classification']) |
| approval = next((row for row in matched if row['kind'] == 'delivery_approval')) |
| controls = [row for row in approval['authorized_variants'] if row['scope']['destination_classification'] == arguments['destination_classification']] |
| return fn__success(controls=ext_deepcopy(controls), applicable_documents=ext_deepcopy(matched), approval_document=ext_deepcopy(approval), examined_records=len(self.governance), reusable_control_bindings=[fn_control_binding(row) for row in approval['authorized_variants']]) |
| target = self.targets.get(arguments.get('request_ref')) |
| if name == 'commit_query_delivery' and regional and (target is not None): |
| record = self.control_registry.get(arguments.get('control_record_id')) |
| sensitive = target['destination_classification'] in DATA_SENSITIVE |
| if sensitive and (not record or record['status'] != 'approved' or record['scope'].get('destination_region') != self._region(target)): |
| return fn__error('CONTROL_SCOPE_MISMATCH', 'approval does not cover the destination scope') |
| original = ext_deepcopy(record) if record is not None else None |
| try: |
| if record is not None: |
| record['scope'].pop('destination_region', None) |
| with self._resolved_profile(target): |
| result = self._warehouse_independent_world_execute_public(name, arguments) |
| finally: |
| if original is not None: |
| self.control_registry[original['control_record_id']] = original |
| if result['status'] == 'success': |
| result['data']['reusable_control_binding'] = fn_control_binding(original) |
| result['data']['destination_region'] = self._region(target) |
| return result |
| result = self._warehouse_independent_world_execute_public(name, arguments) |
| if name == 'inspect_delivery_packet' and result['status'] == 'success': |
| result['data']['packet']['destination_region'] = self._region(target) |
| return result |
|
|
| def grade_targets(self, targets): |
| if 'E2' not in self.applied_boundary_events: |
| return self._warehouse_evidence_grade_targets(targets) |
| result = {'score': 0, 'complete_artifacts': 0, 'max_score': 25.0 * len(targets), 'targets': []} |
| seen = set() |
| for target in targets: |
| with self._resolved_profile(target): |
| row = self._warehouse_evidence_grade_targets([target])['targets'][0] |
| ledger = next((r for r in self.delivery_ledger if r['request_ref'] == target['request_ref']), None) |
| control = self.control_registry.get(ledger.get('control_record_id')) if ledger else None |
| if target['destination_classification'] in DATA_SENSITIVE and row['milestones']['control_receipt']: |
| if control['scope'].get('destination_region') != self._region(target): |
| row['milestones']['control_receipt'] = False |
| row['score'] -= 4.0 |
| row['complete'] = False |
| if target['request_ref'] in seen: |
| row.update(duplicate_target=True, score=0.0, complete=False) |
| seen.add(target['request_ref']) |
| result['targets'].append(row) |
| result['score'] = sum((row['score'] for row in result['targets'])) |
| result['complete_artifacts'] = sum((row['complete'] for row in result['targets'])) |
| return result |
|
|
| def dispatch(self, name, arguments, actor_id='warehouse-delivery-operator:northshore-holdings'): |
| key = mod_json.dumps(arguments, sort_keys=True) |
| if name == 'commit_query_delivery' and actor_id == 'warehouse-delivery-operator:northshore-holdings' and (key in self._own_commits): |
| result = ext_deepcopy(self._own_commits[key]) |
| result['data'].update(confirmation_only=True, budget=self._budget_receipt(0), logical_work={'units': 0, 'basis': 'own_current_episode_saved_receipt'}) |
| return result |
| result = self._warehouse_scope_dispatch(name, arguments, actor_id) |
| if name == 'commit_query_delivery' and result.get('status') == 'success': |
| result['data'].pop('task_id', None) |
| result['data']['event_id'] = fn_public_task_2(self.active_task_id)['event_id'] |
| self._own_commits[key] = ext_deepcopy(result) |
| return result |
|
|
| def grade(self, task_id=None): |
| if (task_id or self.active_task_id) != self.active_task_id or self.active_task_id not in DATA_TASK_IDS: |
| raise ValueError('only the active warehouse task may be graded') |
| value = self.grade_targets(self._task_targets) |
| value.update(task_id=self.active_task_id, remaining_budget=self.remaining) |
| return value |
|
|
| def public_tool_schemas(self, role='warehouse_delivery_operator'): |
| return ext_deepcopy(DATA_TOOLS_2) if role == 'warehouse_delivery_operator' else [] |
|
|
| def _business_snapshot(self): |
| value = self._warehouse_scope_business_snapshot() |
| value['business_tool_surface_sha256'] = 'ad21de00377c73c295f5bdf1ed594316432633f35051442fb01ef5a163ef06d6' |
| return value |
|
|
| def _matching_documents(self, priority, classification): |
| return [row for row in self.governance if fn_applicable(row, priority, classification)] |
|
|
| def apply_structure_drift(self, event_id='evt-warehouse-routing-index-8430c971'): |
| if event_id != 'evt-warehouse-routing-index-8430c971': |
| raise ValueError('unregistered Warehouse boundary') |
| before = self.business_hash() |
| applied = event_id not in self.applied_boundary_events |
| if applied: |
| self.structure_moved = True |
| self.structure_authority = fn_authority(True) |
| self.applied_boundary_events.add(event_id) |
| return {'event_id': event_id, 'applied': applied, 'idempotent_noop': not applied, 'application_count': 1, 'before_world_sha256': before, 'after_world_sha256': self.business_hash()} |
|
|
| def apply_drift(self, drift_id='evt-warehouse-routing-index-8430c971'): |
| return self.apply_structure_drift(drift_id) |
|
|
| def _directory(self): |
| rows = [] |
| for (atom, binding) in self.structure_authority.items(): |
| for route_id in (binding['route_id'], fn_opaque('route', atom, 'archive')): |
| rows.append({'lane_ref': binding['lane_ref'], 'route_id': route_id}) |
| return sorted(rows, key=lambda row: fn_opaque('order', row['route_id'])) |
|
|
| def _budget_receipt(self, charged): |
| result = self._cloud_data_warehouse_successor_budget_receipt(charged) |
| result.update(call_limit=64, write_limit=12) |
| return result |
|
|
| @property |
| def activated_tasks(self): |
| return tuple(self._activated_tasks) |
|
|
| @property |
| def current_policy(self): |
| return dict(self.policy_by_cell) |
|
|
| @property |
| def current_targets(self): |
| return tuple((ext_deepcopy(row) for row in self._task_targets)) |
|
|
| def _permission_authority(self): |
| dataset_ids = {row['destination_dataset_id'] for targets in self._variant_targets.values() for row in targets} |
| user_ids = {row['operator_user_id'] for targets in self._variant_targets.values() for row in targets} |
| return sorted([{'grant_id': row.get('grant_id'), 'dataset_id': row.get('dataset_id'), 'user_id': row.get('user_id'), 'role': row.get('role'), 'scope': row.get('scope'), 'status': row.get('status')} for row in self.manager.list_entities('access_grant') if row.get('dataset_id') in dataset_ids and row.get('user_id') in user_ids], key=lambda row: str(row['grant_id'])) |
|
|
| def _resource_authority(self): |
| warehouses = sorted([{'warehouse_id': row.get('warehouse_id'), 'org_id': row.get('org_id'), 'resource_group': row.get('resource_group'), 'status': row.get('status'), 'daily_credit_limit': row.get('daily_credit_limit')} for row in self.manager.list_entities('warehouse')], key=lambda row: str(row['warehouse_id'])) |
| quotas = sorted([{'quota_id': row.get('quota_id'), 'org_id': row.get('org_id'), 'resource_group': row.get('resource_group'), 'warehouse_id': row.get('warehouse_id'), 'monthly_credit_limit': row.get('monthly_credit_limit'), 'enforcement_mode': row.get('enforcement_mode'), 'status': row.get('status')} for row in self.manager.list_entities('quota_policy')], key=lambda row: str(row['quota_id'])) |
| return {'warehouses': warehouses, 'quota_policies': quotas} |
|
|
| def current_episode_events(self): |
| return ext_deepcopy(self.receipts) |
|
|
| def lineage_hash(self): |
| return fn_digest(self.snapshot()) |
|
|
| @property |
| def remaining(self): |
| return self.work_unit_limit - self.work_units |
|
|
| def close(self): |
| self._runtime.cleanup() |
|
|
| def _seed_raw_state(self): |
| catalog = fn__load_source_catalog(str(self.source)) |
| query_ids = {target['query_job_id'] for target in self.targets.values()} |
| dataset_ids = {target['destination_dataset_id'] for target in self.targets.values()} |
| user_ids = {target['operator_user_id'] for target in self.targets.values()} |
| warehouse_ids = {target['warehouse_id'] for target in self.targets.values()} |
| queries = [row for row in catalog['query_job'] if row.get('query_job_id') in query_ids] |
| datasets = [row for row in catalog['dataset'] if row.get('dataset_id') in dataset_ids] |
| users = [row for row in catalog['user'] if row.get('user_id') in user_ids] |
| warehouses = [row for row in catalog['warehouse'] if row.get('warehouse_id') in warehouse_ids] |
| org_ids = {row['org_id'] for row in queries + datasets + users + warehouses} |
| organizations = [row for row in catalog['organization'] if row.get('org_id') in org_ids] |
| grants = [row for row in catalog['access_grant'] if row.get('dataset_id') in dataset_ids and row.get('user_id') in user_ids] |
| groups = {row['resource_group'] for row in warehouses} |
| policies = [row for row in catalog['quota_policy'] if row.get('org_id') in org_ids and row.get('resource_group') in groups] |
| required_counts = {'query_job': len(query_ids), 'dataset': len(dataset_ids), 'user': len(user_ids), 'warehouse': len(warehouse_ids)} |
| actual_counts = {'query_job': len(queries), 'dataset': len(datasets), 'user': len(users), 'warehouse': len(warehouses)} |
| if actual_counts != required_counts: |
| raise ValueError(f'raw target fixture is incomplete: {actual_counts} != {required_counts}') |
| self.manager.db._data = {'organization': mod_copy.deepcopy(organizations), 'user': mod_copy.deepcopy(users), 'warehouse': mod_copy.deepcopy(warehouses), 'dataset': mod_copy.deepcopy(datasets), 'table': [], 'column': [], 'access_grant': mod_copy.deepcopy(grants), 'query_job': mod_copy.deepcopy(queries), 'import_job': [], 'export_job': [], 'cost_usage_record': [], 'quota_policy': mod_copy.deepcopy(policies)} |
| self._validate_target_bindings() |
|
|
| def _validate_target_bindings(self): |
| queries = fn__index(self.manager.list_entities('query_job'), 'query_job_id') |
| datasets = fn__index(self.manager.list_entities('dataset'), 'dataset_id') |
| warehouses = fn__index(self.manager.list_entities('warehouse'), 'warehouse_id') |
| users = fn__index(self.manager.list_entities('user'), 'user_id') |
| for target in self.targets.values(): |
| query = queries[target['query_job_id']] |
| dataset = datasets[target['destination_dataset_id']] |
| warehouse = warehouses[target['warehouse_id']] |
| user = users[target['operator_user_id']] |
| if query.get('priority') != target['query_priority']: |
| raise ValueError('target query priority differs from raw state') |
| if dataset.get('classification') != target['destination_classification']: |
| raise ValueError('target dataset classification differs from raw state') |
| if not query.get('org_id') == dataset.get('org_id') == warehouse.get('org_id') == user.get('org_id'): |
| raise ValueError('target route crosses raw organization scope') |
| if query.get('warehouse_id') != warehouse.get('warehouse_id'): |
| raise ValueError('target warehouse differs from raw query binding') |
| if query.get('status') != 'succeeded' or int(query.get('result_row_count') or 0) <= 0: |
| raise ValueError('target query is not a non-empty succeeded result') |
| if dataset.get('status') != 'active' or warehouse.get('status') != 'active' or user.get('status') != 'active': |
| raise ValueError('target route contains inactive raw state') |
| if not self._has_write_access(target['destination_dataset_id'], target['operator_user_id']): |
| raise ValueError('target operator lacks a raw writer grant') |
|
|
| def configure_fault(self, tool, after_mutations=1): |
| self._fault = {'tool': tool, 'after_mutations': int(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 RuntimeError('case-local injected write failure') |
|
|
| def _raw_database_snapshot(self): |
| return mod_copy.deepcopy(self.manager.db.snapshot()) |
|
|
| def _restore_raw_database(self, snapshot): |
| self.manager.db._data = mod_copy.deepcopy(snapshot) |
|
|
| def business_hash(self): |
| return mod_hashlib.sha256(fn__canonical(self._business_snapshot()).encode('ascii')).hexdigest() |
|
|
| def semantic_hash(self): |
| return mod_hashlib.sha256(fn__canonical(self.snapshot()).encode('ascii')).hexdigest() |
|
|
| def _target(self, request_ref): |
| return self.targets.get(request_ref) |
|
|
| def _get(self, entity, identifier, field): |
| return self.manager.get_entity(entity, identifier, id_field=field) |
|
|
| def _has_write_access(self, dataset_id, user_id): |
| user = self._get('user', user_id, 'user_id') |
| if user and user.get('role') in {'admin', 'steward'}: |
| return True |
| return any((row.get('dataset_id') == dataset_id and row.get('user_id') == user_id and (row.get('status') == 'active') and (row.get('role') in {'writer', 'admin', 'owner'}) and (row.get('scope') == 'dataset' or row.get('table_id') is None) for row in self.manager.list_entities('access_grant'))) |
|
|
| def _find_delivery_route(self, arguments): |
| target = self._target(arguments['request_ref']) |
| if target is None or target['request_ref'] not in self.active_request_refs: |
| return fn__success(matches=[]) |
| query = self._get('query_job', target['query_job_id'], 'query_job_id') |
| return fn__success(matches=[{'request_ref': target['request_ref'], 'route_id': target['route_id'], 'organization_id': query.get('org_id') if query else None}]) |
|
|
| def _inspect_delivery_packet(self, arguments): |
| target = self._target(arguments['request_ref']) |
| if target is None or target['request_ref'] not in self.active_request_refs or arguments['route_id'] != target['route_id']: |
| return fn__error('DELIVERY_PACKET_NOT_FOUND', 'no active delivery packet matches the supplied lookup') |
| query = self._get('query_job', target['query_job_id'], 'query_job_id') |
| dataset = self._get('dataset', target['destination_dataset_id'], 'dataset_id') |
| warehouse = self._get('warehouse', target['warehouse_id'], 'warehouse_id') |
| user = self._get('user', target['operator_user_id'], 'user_id') |
| committed = next((row for row in self.delivery_ledger if row['request_ref'] == target['request_ref']), None) |
| return fn__success(packet={'request_ref': target['request_ref'], 'route_id': target['route_id'], 'query_job_id': target['query_job_id'], 'query_status': query.get('status') if query else None, 'query_priority': query.get('priority') if query else None, 'result_row_count': query.get('result_row_count') if query else None, 'destination_dataset_id': target['destination_dataset_id'], 'destination_dataset_status': dataset.get('status') if dataset else None, 'destination_classification': dataset.get('classification') if dataset else None, 'operator_user_id': target['operator_user_id'], 'operator_status': user.get('status') if user else None, 'warehouse_id': target['warehouse_id'], 'warehouse_status': warehouse.get('status') if warehouse else None, 'table_name': target['table_name'], 'destination_uri': target['destination_uri'], 'committed': committed is not None}) |
|
|
| def _binding_guard(self, target, arguments): |
| fields = ('route_id', 'query_job_id', 'destination_dataset_id', 'operator_user_id', 'warehouse_id', 'table_name', 'destination_uri') |
| if any((arguments.get(field) != target[field] for field in fields)): |
| raise Abort(fn__error('DELIVERY_BINDING_MISMATCH', 'supplied identifiers do not form the active governed delivery packet')) |
|
|
| def _raw_failure(self, operation, result): |
| message = str(result.get('message') or 'raw operation rejected') |
| return Abort(fn__error('UPSTREAM_OPERATION_REJECTED', f'{operation} rejected: {message}')) |
|
|
| def _matching_policies(self, org_id, warehouse): |
| return [row for row in self.manager.list_entities('quota_policy') if row.get('org_id') == org_id and row.get('status') == 'active' and (row.get('resource_group') == warehouse.get('resource_group')) and (row.get('warehouse_id') in {None, warehouse.get('warehouse_id')})] |
|
|
| def _commit_query_delivery(self, arguments): |
| request_ref = arguments['request_ref'] |
| target = self._target(request_ref) |
| if target is None or request_ref not in self.active_request_refs: |
| raise Abort(fn__error('TARGET_SCOPE_FORBIDDEN', 'request is not active in the current delivery set')) |
| self._binding_guard(target, arguments) |
| query = self._get('query_job', target['query_job_id'], 'query_job_id') |
| dataset = self._get('dataset', target['destination_dataset_id'], 'dataset_id') |
| warehouse = self._get('warehouse', target['warehouse_id'], 'warehouse_id') |
| user = self._get('user', target['operator_user_id'], 'user_id') |
| if not all((query, dataset, warehouse, user)): |
| raise Abort(fn__error('DELIVERY_STATE_INVALID', 'the governed delivery packet is incomplete')) |
| if not query['org_id'] == dataset['org_id'] == warehouse['org_id'] == user['org_id']: |
| raise Abort(fn__error('DELIVERY_SCOPE_INVALID', 'the governed delivery packet crosses organization scope')) |
| if query.get('status') != 'succeeded' or int(query.get('result_row_count') or 0) <= 0: |
| raise Abort(fn__error('QUERY_NOT_DELIVERABLE', 'the query has no succeeded non-empty result')) |
| if dataset.get('status') != 'active' or warehouse.get('status') != 'active' or user.get('status') != 'active': |
| raise Abort(fn__error('DELIVERY_RESOURCE_INACTIVE', 'a required delivery resource is not active')) |
| if not self._has_write_access(dataset['dataset_id'], user['user_id']): |
| raise Abort(fn__error('WRITE_ACCESS_REQUIRED', 'the bound operator lacks destination write access')) |
| cell = (str(query['priority']), str(dataset['classification'])) |
| expected_profile = self.policy_by_cell.get(cell) |
| if arguments['delivery_profile_id'] != expected_profile: |
| raise Abort(fn__error('DELIVERY_PROFILE_MISMATCH', 'selected delivery profile is not valid for the current observable conditions')) |
| profile = DATA_DELIVERY_PROFILES[expected_profile] |
| existing = next((row for row in self.delivery_ledger if row['request_ref'] == request_ref), None) |
| if existing is not None: |
| if existing.get('delivery_profile_id') != expected_profile: |
| raise Abort(fn__error('DELIVERY_ALREADY_COMMITTED', 'delivery was already committed differently')) |
| return fn__success(**mod_copy.deepcopy(existing), idempotent=True) |
| materialized_size = round(max(float(query.get('bytes_scanned_gb') or 1) * 0.18, 0.1), 3) |
| export_credits = round(max(materialized_size * 0.04, 0.05), 3) |
| if float(warehouse.get('credits_used_today') or 0) + export_credits > float(warehouse.get('daily_credit_limit') or 0): |
| raise Abort(fn__error('WAREHOUSE_DAILY_CREDIT_EXCEEDED', 'warehouse delivery capacity is exhausted')) |
| policies = self._matching_policies(query['org_id'], warehouse) |
| for policy in policies: |
| if policy.get('enforcement_mode') == 'block' and float(policy.get('current_month_credits') or 0) + export_credits > float(policy.get('monthly_credit_limit') or 0): |
| raise Abort(fn__error('MONTHLY_CREDIT_POLICY_BLOCKED', 'active delivery credit policy would be exceeded')) |
| materialized = self.raw_tools.materialize_query_result(state_manager=self.manager, query_job_id=query['query_job_id'], destination_dataset_id=dataset['dataset_id'], table_name=target['table_name'], table_type=profile['table_type'], replace_existing=False) |
| if materialized.get('status') != 'success': |
| raise self._raw_failure('materialization', materialized) |
| self._after_mutation() |
| table = materialized['data']['destination_table'] |
| created_export = self.raw_tools.create_export_job(state_manager=self.manager, source_table_id=table['table_id'], warehouse_id=warehouse['warehouse_id'], requested_by_user_id=user['user_id'], destination_uri=target['destination_uri'], format=profile['format'], compression=profile['compression'], expires_at='2026-10-25T12:00:00Z', scheduled_at='2026-09-25T12:00:00Z') |
| if created_export.get('status') != 'success': |
| raise self._raw_failure('export creation', created_export) |
| self._after_mutation() |
| export_job = created_export['data']['export_job'] |
| finalized = self.raw_tools.finalize_export_job(state_manager=self.manager, export_job_id=export_job['export_job_id'], result_status='succeeded', row_count=int(query['result_row_count']), bytes_exported_gb=materialized_size) |
| if finalized.get('status') != 'success': |
| raise self._raw_failure('export finalization', finalized) |
| self._after_mutation() |
| for policy in policies: |
| policy['current_month_credits'] = round(float(policy.get('current_month_credits') or 0) + export_credits, 3) |
| policy['updated_at'] = '2026-09-25T12:00:00Z' |
| self.manager.replace_entity('quota_policy', policy['quota_id'], policy) |
| self._after_mutation() |
| ledger = {'delivery_id': f'delivery-{request_ref.lower()}', 'task_id': self.active_task_id, 'request_ref': request_ref, 'route_id': target['route_id'], 'query_job_id': query['query_job_id'], 'destination_dataset_id': dataset['dataset_id'], 'operator_user_id': user['user_id'], 'warehouse_id': warehouse['warehouse_id'], 'query_priority': query['priority'], 'destination_classification': dataset['classification'], 'delivery_profile_id': expected_profile, 'table_id': table['table_id'], 'export_job_id': export_job['export_job_id'], 'export_credits': export_credits, 'quota_accounted': True, 'committed_at': '2026-09-25T12:00:00Z'} |
| self.delivery_ledger.append(ledger) |
| self._after_mutation() |
| return fn__success(**mod_copy.deepcopy(ledger), idempotent=False) |
|
|
| def _execute(self, name, arguments): |
| if name == 'find_delivery_route': |
| return self._find_delivery_route(arguments) |
| if name == 'inspect_delivery_packet': |
| return self._inspect_delivery_packet(arguments) |
| if name == 'commit_query_delivery': |
| return self._commit_query_delivery(arguments) |
| return fn__error('TOOL_NOT_ALLOWED', 'tool is not in the learner allowlist') |
|
|
| def apply_policy_drift(self, event_id): |
| if event_id in self.applied_boundary_events: |
| return {'status': 'success', 'event_id': event_id, 'idempotent': True, 'changed': []} |
| changed = [] |
| for cell in sorted(DATA_CHANGED_CELLS): |
| before = self.policy_by_cell[cell] |
| after = DATA_POST_POLICY_BY_CELL[cell] |
| self.policy_by_cell[cell] = after |
| changed.append({'cell': ':'.join(cell), 'before': before, 'after': after}) |
| self.policy_epoch = 'post' |
| self.applied_boundary_events.add(event_id) |
| return {'status': 'success', 'event_id': event_id, 'idempotent': False, 'changed': changed} |
|
|
| def _warehouse_scope_init(self, *, allowance=68, source_root=CASE_DIR / 'raw'): |
| self._warehouse_scope_init_2(allowance=allowance, source_root=source_root) |
| variants = {(task_id, moved): fn_frontier_targets(task_id, moved) for task_id in DATA_TASK_IDS_2 for moved in (False, True)} |
| for rows in variants.values(): |
| for item in rows: |
| if self._get('query_job', item['query_job_id'], 'query_job_id') is not None: |
| continue |
| query = ext_deepcopy(self._get('query_job', item['source_query_job_id'], 'query_job_id')) |
| if query is None: |
| raise ValueError('Warehouse v8 query template is absent') |
| query.update(query_job_id=item['query_job_id'], destination_table_id=None) |
| self.manager.add_entity('query_job', query, id_field='query_job_id') |
| self._variant_targets = {key: tuple((ext_deepcopy(item) for item in rows)) for (key, rows) in variants.items()} |
| self.targets = {f'{task_id}:{int(moved)}:{index}': ext_deepcopy(target) for ((task_id, moved), rows) in variants.items() for (index, target) in enumerate(rows, 1)} |
| self._validate_target_bindings() |
| self.targets = {} |
|
|
| def _cloud_data_warehouse_successor_activate_task(self, task_id, request_refs, allowance=50): |
| requested = {str(value) for value in request_refs} |
| unknown = requested - set(self.targets) |
| if unknown: |
| raise ValueError(f'unknown active target reference(s): {sorted(unknown)}') |
| self.active_task_id = str(task_id) |
| self.active_request_refs = requested |
| self.work_unit_limit = int(allowance) |
| self.work_units = 0 |
| self.calls = 0 |
| self.writes = 0 |
| self.receipts = [] |
| return {'status': 'success', 'task_id': self.active_task_id, 'active_target_count': len(requested), 'allowance': self.work_unit_limit} |
|
|
| def _warehouse_regional_approval_world_snapshot(self): |
| value = self._warehouse_document_opportunity_world_snapshot() |
| if not getattr(self, '_restoring_regional', False): |
| value['regional_approval_contract'] = {'case_version': 'warehouse-regional-approval-evolution-v6', 'blueprint_sha256': ext_digest(fn_blueprint_2())} |
| return value |
|
|
| def _warehouse_regional_approval_world_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| expected = {'case_version': 'warehouse-regional-approval-evolution-v6', 'blueprint_sha256': ext_digest(fn_blueprint_2())} |
| if value.pop('regional_approval_contract', None) != expected: |
| raise ValueError('Warehouse regional approval snapshot identity differs') |
| self._restoring_regional = True |
| try: |
| self._warehouse_document_opportunity_world_restore(value) |
| finally: |
| self._restoring_regional = False |
| if self.snapshot() != snapshot: |
| raise ValueError('Warehouse regional approval snapshot did not round trip') |
|
|
| def _warehouse_evolution_apply_event(self, event_id): |
| if event_id not in {'E1', 'E2'}: |
| raise ValueError('unregistered warehouse event') |
| before = self.business_hash() |
| if event_id in self.applied_boundary_events: |
| return {'event_id': event_id, 'applied': False, 'before': before, 'after': before} |
| if event_id == 'E1': |
| self.structure_moved = True |
| self.structure_authority = fn_authority(True) |
| else: |
| if 'E1' not in self.applied_boundary_events: |
| raise ValueError('warehouse events must follow their declared order') |
| for (cell, profile_id) in DATA_RULE_AFTER.items(): |
| control = next((c for c in self.control_registry.values() if (c['scope']['query_priority'], c['scope']['destination_classification']) == cell)) |
| profile = DATA_DELIVERY_PROFILES[profile_id] |
| control['clauses'].update(materialized_table_type=profile['table_type'], export_format=profile['format'], export_compression=profile['compression']) |
| self.policy_by_cell[cell] = profile_id |
| for document in self.governance: |
| for (index, variant) in enumerate(document.get('authorized_variants', [])): |
| if variant['control_record_id'] == control['control_record_id']: |
| document['authorized_variants'][index] = ext_deepcopy(control) |
| self.policy_epoch = 'evolution-E2' |
| self.applied_boundary_events.add(event_id) |
| return {'event_id': event_id, 'applied': True, 'before': before, 'after': self.business_hash()} |
|
|
| def _warehouse_independent_world_execute_public(self, name, arguments): |
| target = self.targets.get(arguments.get('request_ref')) |
| if name != 'commit_query_delivery' or target is None: |
| return self._warehouse_scope_execute_public(name, arguments) |
| original = self._task_targets |
| self._task_targets = [target] + [row for row in original if row is not target and row != target] |
| try: |
| return self._warehouse_scope_execute_public(name, arguments) |
| finally: |
| self._task_targets = original |
|
|
| def _warehouse_evidence_grade_targets(self, rows): |
| result = self._cloud_data_warehouse_successor_grade_targets(rows) |
| for (item, row) in zip(rows, result['targets']): |
| ledger = next((entry for entry in self.delivery_ledger if entry['request_ref'] == item['request_ref']), None) |
| control = self.control_registry.get(ledger.get('control_record_id')) if ledger else None |
| valid = bool(control and control['status'] == 'approved' and (control['scope']['query_priority'] == item['query_priority']) and (control['scope']['destination_classification'] == item['destination_classification'])) |
| if row['milestones']['control_receipt'] and (not valid): |
| row['milestones']['control_receipt'] = False |
| row['score'] -= 4.0 |
| row['complete'] = False |
| result['score'] = sum((row['score'] for row in result['targets'])) |
| result['complete_artifacts'] = sum((row['complete'] for row in result['targets'])) |
| return result |
|
|
| def _warehouse_scope_dispatch(self, name, arguments, actor_id='warehouse-delivery-operator:northshore-holdings'): |
| if name == 'commit_query_delivery' and isinstance(arguments, dict): |
| route = arguments.get('route_id') |
| authorization = arguments.get('lane_authorization') |
| if isinstance(route, str) and isinstance(authorization, str) and ((route, authorization) not in DATA_KNOWN_LANE_TUPLES): |
| result = fn__error('LANE_BINDING_TUPLE_INCONSISTENT', 'route_id and lane_authorization were not emitted together by positive evidence') |
| result['data']['budget'] = self._budget_receipt(0) |
| result['data']['recovery'] = 'Copy both fields verbatim from the same exact reusable_lane_binding.' |
| return result |
| return self._warehouse_scope_dispatch_2(name, arguments, actor_id) |
|
|
| def _warehouse_scope_business_snapshot(self): |
| value = self._warehouse_evidence_business_snapshot() |
| value['governance_documents'] = ext_deepcopy(self.governance) |
| value['business_tool_surface_sha256'] = 'e097c1a72aed2e241dde85b64b5b4e5fd0287805c69a402cfd43a4cbea870499' |
| return value |
|
|
| def _cloud_data_warehouse_successor_budget_receipt(self, charged): |
| return {'charged': charged, 'remaining': self.remaining, 'work_units_used': self.work_units, 'work_unit_limit': self.work_unit_limit, 'calls_used': self.calls, 'call_limit': 12, 'writes_used': self.writes, 'write_limit': 5} |
|
|
| def _warehouse_scope_init_2(self, *, allowance=68, source_root=CASE_DIR / 'raw'): |
| self.governance = fn_governance_documents() |
| self._warehouse_evidence_init(allowance=allowance, source_root=source_root) |
|
|
| def _warehouse_document_opportunity_world_snapshot(self): |
| value = self._warehouse_prefix_opportunity_world_snapshot() |
| if not getattr(self, '_restoring_document_opportunity', False): |
| value['document_opportunity_contract'] = {'case_version': 'warehouse-document-opportunity-evolution-v5', 'blueprint_sha256': ext_digest(fn_blueprint_3())} |
| return value |
|
|
| def _warehouse_document_opportunity_world_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| expected = {'case_version': 'warehouse-document-opportunity-evolution-v5', 'blueprint_sha256': ext_digest(fn_blueprint_3())} |
| if value.pop('document_opportunity_contract', None) != expected: |
| raise ValueError('Warehouse document-opportunity snapshot identity differs') |
| self._restoring_document_opportunity = True |
| try: |
| self._warehouse_prefix_opportunity_world_restore(value) |
| finally: |
| self._restoring_document_opportunity = False |
| if self.snapshot() != snapshot: |
| raise ValueError('Warehouse document-opportunity snapshot did not round trip') |
|
|
| def _warehouse_scope_execute_public(self, name, arguments): |
| result = self._warehouse_scope_execute_public_2(name, arguments) |
| if result.get('status') != 'success': |
| return result |
| data = result['data'] |
| if name in {'inspect_delivery_packet', 'commit_query_delivery'}: |
| lane = data.get('reusable_lane_binding') |
| if lane is not None: |
| data['reusable_lane_binding'] = fn__canonicalize_lane(lane) |
| if name == 'read_delivery_controls': |
| data['reusable_control_bindings'] = fn_reusable_control_bindings(result) |
| elif name == 'list_delivery_profiles': |
| data['reusable_profile_catalog'] = fn_reusable_profile_catalog() |
| elif name == 'commit_query_delivery': |
| target = self.targets.get(arguments.get('request_ref')) |
| if target is not None: |
| key = target['query_priority'] + ':' + target['destination_classification'] |
| data['reusable_control_binding'] = {'key': {'query_priority': target['query_priority'], 'destination_classification': target['destination_classification']}, 'value': {'control_record_id': arguments['control_record_id'], 'delivery_profile_id': arguments['delivery_profile_id']}, 'evidence_state': 'verified_current', 'evidence_kind': 'successful_exact_commit', 'canonical_record': f"CONTROL|{key}|{arguments['control_record_id']}|{arguments['delivery_profile_id']}"} |
| return result |
|
|
| def _cloud_data_warehouse_successor_grade_targets(self, targets): |
| rows = [] |
| seen: set[str] = set() |
| for target in targets: |
| request_ref = str(target['request_ref']) |
| duplicate = request_ref in seen |
| seen.add(request_ref) |
| ledger = next((row for row in self.delivery_ledger if row['request_ref'] == request_ref), None) |
| query = self._get('query_job', target['query_job_id'], 'query_job_id') |
| table = self._get('table', ledger['table_id'], 'table_id') if ledger else None |
| export = self._get('export_job', ledger['export_job_id'], 'export_job_id') if ledger else None |
| columns = [row for row in self.manager.list_entities('column') if ledger and row.get('table_id') == ledger['table_id']] |
| expected_profile_id = self.policy_by_cell[target['query_priority'], target['destination_classification']] |
| profile = DATA_DELIVERY_PROFILES[expected_profile_id] |
| milestones = {'materialized_result': bool(ledger and table and (table.get('dataset_id') == target['destination_dataset_id']) and (table.get('table_type') == profile['table_type']) and (table.get('row_count') == query.get('result_row_count')) and (len(columns) == 3)), 'query_lineage': bool(ledger and query and (query.get('destination_table_id') == ledger.get('table_id'))), 'completed_export': bool(ledger and export and (export.get('status') == 'succeeded') and (export.get('source_table_id') == ledger.get('table_id')) and (export.get('destination_uri') == target['destination_uri']) and (export.get('format') == profile['format']) and (export.get('compression') == profile['compression']) and (export.get('row_count') == query.get('result_row_count'))), 'control_receipt': bool(ledger and ledger.get('delivery_profile_id') == expected_profile_id and (ledger.get('quota_accounted') is True) and (float(ledger.get('export_credits') or 0) > 0))} |
| points = {'materialized_result': 8.0, 'query_lineage': 5.0, 'completed_export': 8.0, 'control_receipt': 4.0} |
| score = 0.0 if duplicate else sum((points[name] for (name, passed) in milestones.items() if passed)) |
| rows.append({'request_ref': request_ref, 'duplicate_target': duplicate, 'milestones': milestones, 'score': score, 'complete': score == 25.0}) |
| total = round(sum((row['score'] for row in rows)), 2) |
| return {'score': total, 'complete_artifacts': sum((row['complete'] for row in rows)), 'max_score': 25.0 * len(rows), 'targets': rows} |
|
|
| def _warehouse_scope_dispatch_2(self, name, arguments, actor_id='warehouse-delivery-operator:northshore-holdings'): |
| desired = DATA_COSTS.get(name) |
| if desired is not None and name == 'read_delivery_controls' and (self.active_task_id is not None) and (self.remaining < desired): |
| result = fn__error('WORK_BUDGET_EXHAUSTED', 'remaining work units cannot fund this operation') |
| result['data']['budget'] = self._budget_receipt(0) |
| return result |
| count_before = self.calls |
| result = self._warehouse_evidence_dispatch(name, arguments, actor_id) |
| if self.calls == count_before: |
| return result |
| extra = DATA_COSTS[name] - DATA_COSTS_2[name] |
| self.work_units += extra |
| result['data']['budget'] = self._budget_receipt(DATA_COSTS[name]) |
| basis = {'find_delivery_route': 'scan_16_candidate_binding_records', 'inspect_delivery_packet': 'six_exact_primary_key_business_record_checks', 'read_delivery_controls': 'evaluate_all_potentially_applicable_governance_documents', 'list_delivery_profiles': 'four_capability_records', 'commit_query_delivery': 'reserved_atomic_materialize_export_accounting_transaction'}[name] |
| ledger = {'units': DATA_COSTS[name], 'basis': basis, 'python_internal_list_scans_and_serialization_are_not_charged': True} |
| if name == 'read_delivery_controls': |
| ledger['examined_records'] = len(self.governance) |
| self.receipts[-1].update(charged=DATA_COSTS[name], logical_work=ext_deepcopy(ledger)) |
| result['data']['logical_work'] = ledger |
| return result |
|
|
| def _warehouse_evidence_business_snapshot(self): |
| value = self._natural_cloud_data_warehouse_successor_business_snapshot() |
| value['control_registry'] = ext_deepcopy(getattr(self, 'control_registry', fn_controls())) |
| value['business_tool_surface_sha256'] = 'debd083bd85e97049dd352b10b07b9b5da8ca9ff27778264e9f45063e9c77ad1' |
| return value |
|
|
| def _warehouse_evidence_init(self, *, allowance, source_root=CASE_DIR / 'raw'): |
| self._natural_cloud_data_warehouse_successor_init(source_root=source_root, budget=allowance) |
| self.control_registry = fn_controls() |
| self._variant_targets = {(task_id, moved): fn_targets_3(task_id, moved) for task_id in DATA_TASK_IDS_2 for moved in (False, True)} |
| for rows in self._variant_targets.values(): |
| for item in rows: |
| query = ext_deepcopy(self._get('query_job', item['source_query_job_id'], 'query_job_id')) |
| query.update(query_job_id=item['query_job_id'], destination_table_id=None) |
| self.manager.add_entity('query_job', query, id_field='query_job_id') |
| self.targets = {} |
| self.structure_authority = fn_authority(False) |
| self._activated_tasks = [] |
| self._task_targets = [] |
| self.initial_budget = allowance |
| self.work_unit_limit = allowance |
|
|
| def _warehouse_prefix_opportunity_world_snapshot(self): |
| value = self._warehouse_tail_coverage_world_snapshot() |
| if not getattr(self, '_restoring_prefix_opportunity', False): |
| value['prefix_opportunity_contract'] = {'case_version': 'warehouse-prefix-opportunity-evolution-v4', 'blueprint_sha256': ext_digest(fn_blueprint_4())} |
| return value |
|
|
| def _warehouse_prefix_opportunity_world_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| expected = {'case_version': 'warehouse-prefix-opportunity-evolution-v4', 'blueprint_sha256': ext_digest(fn_blueprint_4())} |
| if value.pop('prefix_opportunity_contract', None) != expected: |
| raise ValueError('Warehouse prefix-opportunity snapshot version differs') |
| self._restoring_prefix_opportunity = True |
| try: |
| self._warehouse_tail_coverage_world_restore(value) |
| finally: |
| self._restoring_prefix_opportunity = False |
| if self.snapshot() != snapshot: |
| raise ValueError('Warehouse prefix-opportunity snapshot did not round trip') |
|
|
| def _warehouse_scope_execute_public_2(self, name, arguments): |
| result = self._warehouse_scope_execute_public_3(name, arguments) |
| target = self.targets.get(arguments.get('request_ref')) |
| if target is None: |
| return result |
| if name == 'inspect_delivery_packet' and result.get('status') == 'success': |
| result['data']['reusable_lane_binding'] = fn_reusable_lane_binding(target) |
| elif name == 'commit_query_delivery': |
| if result.get('status') == 'success': |
| result['data']['reusable_lane_binding'] = fn_reusable_lane_binding(target) |
| elif result.get('error_code') == 'DELIVERY_BINDING_MISMATCH': |
| result['data']['binding_conflict'] = {'key': {'delivery_lane_ref': target['delivery_lane_ref']}, 'attempted': {'route_id': arguments['route_id'], 'lane_authorization': arguments['lane_authorization']}, 'evidence_state': 'stale', 'replacement_disclosed': False, 'recovery': 'Refresh only this exact active request from positive packet evidence.'} |
| return result |
|
|
| def _warehouse_evidence_dispatch(self, name, arguments, actor_id='warehouse-delivery-operator:northshore-holdings'): |
| if self.active_task_id is None: |
| return fn__error('TASK_NOT_ACTIVE', 'activate a task before dispatch') |
| if name not in DATA_TOOL_MAP: |
| return fn__error('TOOL_NOT_ALLOWED', 'tool is not in the learner allowlist') |
| if actor_id != 'warehouse-delivery-operator:northshore-holdings': |
| return fn__error('ACTOR_NOT_AUTHORIZED', 'actor is not an authorized warehouse delivery operator') |
| invalid = fn__validate_node(arguments, DATA_TOOL_MAP[name]['parameters']) |
| if invalid: |
| return fn__error('INVALID_ARGUMENTS', invalid) |
| if self.calls >= 64 or (name == 'commit_query_delivery' and self.writes >= 12): |
| return fn__error('CALL_LIMIT_EXHAUSTED', 'task operation guard is exhausted') |
| cost = DATA_COSTS_2[name] |
| if cost > self.remaining: |
| result = fn__error('WORK_BUDGET_EXHAUSTED', 'remaining work units cannot fund this operation') |
| result['data']['budget'] = self._budget_receipt(0) |
| return result |
| before = self.business_hash() |
| database = self._raw_database_snapshot() |
| ledger = ext_deepcopy(self.delivery_ledger) |
| (self._active_tool, self._mutation_count) = (name, 0) |
| try: |
| result = self._execute_public(name, ext_deepcopy(arguments)) |
| if result['status'] != 'success': |
| raise Abort(result) |
| except Abort as error: |
| self._restore_raw_database(database) |
| self.delivery_ledger = ledger |
| result = error.result |
| except Exception: |
| self._restore_raw_database(database) |
| self.delivery_ledger = ledger |
| raise |
| finally: |
| (self._active_tool, self._mutation_count) = (None, 0) |
| self.calls += 1 |
| self.writes += int(name == 'commit_query_delivery') |
| self.work_units += cost |
| result.setdefault('data', {})['budget'] = self._budget_receipt(cost) |
| if result['data'].get('task_id') in DATA_TASK_IDS_2: |
| task_id = result['data'].pop('task_id') |
| result['data']['event_id'] = fn_opaque('EV', task_id).upper() |
| self.receipts.append({'index': len(self.receipts) + 1, 'task_id': self.active_task_id, 'tool': name, 'arguments': ext_deepcopy(arguments), 'status': result['status'], 'error_code': result.get('error_code'), 'charged': cost, 'before_business_hash': before, 'after_business_hash': self.business_hash()}) |
| return ext_deepcopy(result) |
|
|
| def _natural_cloud_data_warehouse_successor_business_snapshot(self): |
| value = self._structural_cloud_data_warehouse_successor_business_snapshot() |
| value['structure_authority'] = ext_deepcopy(self.structure_authority) |
| value['business_tool_surface_sha256'] = 'bf695e60b3b72bc51e2e546788aae608ee8ff0d3993a046ae4c7dbbbd4558a93' |
| return value |
|
|
| def _natural_cloud_data_warehouse_successor_init(self, source_root=None, source=None, budget=25): |
| resolved = ext_Path(source_root or source or CASE_DIR / 'raw').resolve() |
| self._structural_cloud_data_warehouse_successor_init(resolved, budget=budget) |
| variants = {(task_id, moved): fn_stream_targets(task_id, moved=moved) for task_id in DATA_TASK_IDS_3 for moved in (False, True)} |
| for targets in variants.values(): |
| for target in targets: |
| if self._get('query_job', target['query_job_id'], 'query_job_id') is not None: |
| continue |
| source_query = self._get('query_job', target['source_query_job_id'], 'query_job_id') |
| if source_query is None: |
| raise ValueError('structure successor query template is absent') |
| query = ext_deepcopy(source_query) |
| query['query_job_id'] = target['query_job_id'] |
| query['destination_table_id'] = None |
| self.manager.add_entity('query_job', query, id_field='query_job_id') |
| self._variant_targets = {key: tuple((ext_deepcopy(row) for row in rows)) for (key, rows) in variants.items()} |
| self.targets = {f'{task_id}:{int(moved)}:{index}': ext_deepcopy(target) for ((task_id, moved), targets) in variants.items() for (index, target) in enumerate(targets, 1)} |
| self._validate_target_bindings() |
| self.structure_moved = False |
| self.structure_authority = ext_deepcopy(DATA_PRE_STRUCTURE_AUTHORITY) |
| self._activated_tasks = [] |
| self._task_targets = [] |
| self.work_unit_limit = budget |
|
|
| def _warehouse_tail_coverage_world_snapshot(self): |
| value = self._warehouse_independent_world_snapshot() |
| if not getattr(self, '_restoring_tail_coverage', False): |
| value['tail_coverage_contract'] = {'case_version': 'warehouse-tail-coverage-evolution-v3', 'blueprint_sha256': ext_digest(fn_blueprint_5())} |
| return value |
|
|
| def _warehouse_tail_coverage_world_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| expected = {'case_version': 'warehouse-tail-coverage-evolution-v3', 'blueprint_sha256': ext_digest(fn_blueprint_5())} |
| if value.pop('tail_coverage_contract', None) != expected: |
| raise ValueError('Warehouse tail-coverage snapshot version differs') |
| self._restoring_tail_coverage = True |
| try: |
| self._warehouse_independent_world_restore(value) |
| finally: |
| self._restoring_tail_coverage = False |
| if self.snapshot() != snapshot: |
| raise ValueError('Warehouse tail-coverage snapshot did not round trip') |
|
|
| def _warehouse_scope_execute_public_3(self, name, arguments): |
| if name == 'read_delivery_controls': |
| matched = self._matching_documents(arguments['query_priority'], arguments['destination_classification']) |
| approval = next((row for row in matched if row['kind'] == 'delivery_approval')) |
| control = next((row for row in approval['authorized_variants'] if row['scope']['destination_classification'] == arguments['destination_classification'])) |
| return fn__success(control=ext_deepcopy(control), applicable_documents=ext_deepcopy(matched), approval_document=ext_deepcopy(approval), examined_records=len(self.governance)) |
| if name == 'commit_query_delivery': |
| target = self.targets.get(arguments['request_ref']) |
| if target is not None: |
| matched = self._matching_documents(target['query_priority'], target['destination_classification']) |
| if len(matched) != 3 or any((row['status'] != 'approved' for row in matched)): |
| return fn__error('GOVERNANCE_AUTHORITY_UNAVAILABLE', 'applicable governance authority is not approved') |
| org = next((row for row in matched if row['kind'] == 'organization_baseline')) |
| source = next((row for row in matched if row['kind'] == 'source_priority_control')) |
| approval = next((row for row in matched if row['kind'] == 'delivery_approval')) |
| query = self._get('query_job', target['query_job_id'], 'query_job_id') |
| if query.get('org_id') != org['requirements']['organization_id'] or org['requirements']['operator_role'] != 'warehouse_delivery_operator': |
| return fn__error('GOVERNANCE_ORGANIZATION_MISMATCH', 'organization baseline does not authorize this operator scope') |
| if query.get('status') != source['requirements']['query_status'] or query.get('result_row_count', 0) < source['requirements']['minimum_result_rows']: |
| return fn__error('GOVERNANCE_SOURCE_MISMATCH', 'source does not satisfy the applicable priority control') |
| if arguments['control_record_id'] not in {row['control_record_id'] for row in approval['authorized_variants']}: |
| return fn__error('CONTROL_SCOPE_MISMATCH', 'control reference is outside the applicable approval document') |
| return self._warehouse_evidence_execute_public(name, arguments) |
|
|
| def _structural_cloud_data_warehouse_successor_business_snapshot(self): |
| value = self._cloud_data_warehouse_successor_business_snapshot() |
| value.update({'structure_authority': ext_deepcopy(self.structure_authority), 'rule_authority': fn_canonical_policy_table(self.policy_by_cell), 'permission_authority': self._permission_authority(), 'resource_authority': self._resource_authority(), 'business_tool_surface_sha256': fn_digest(DATA_PROVIDER_TOOLS)}) |
| return value |
|
|
| def _structural_cloud_data_warehouse_successor_init(self, source_root=None, source=None, budget=50): |
| resolved = ext_Path(source_root or source or CASE_DIR / 'raw').resolve() |
| variants = {(task_id, moved): fn_stream_targets_2(task_id, moved=moved) for task_id in DATA_TASK_IDS_4 for moved in (False, True)} |
| bootstrap = [] |
| for ((task_id, moved), targets) in variants.items(): |
| for target in targets: |
| row = ext_deepcopy(target) |
| row['request_ref'] = f"{target['request_ref']}:{task_id}:{int(moved)}" |
| row['query_job_id'] = target['source_query_job_id'] |
| bootstrap.append(row) |
| self._cloud_data_warehouse_successor_init(resolved, bootstrap, budget=budget) |
| for targets in variants.values(): |
| for target in targets: |
| if self._get('query_job', target['query_job_id'], 'query_job_id') is not None: |
| continue |
| source_query = self._get('query_job', target['source_query_job_id'], 'query_job_id') |
| if source_query is None: |
| raise ValueError('structure successor query template is absent') |
| query = ext_deepcopy(source_query) |
| query['query_job_id'] = target['query_job_id'] |
| query['destination_table_id'] = None |
| self.manager.add_entity('query_job', query, id_field='query_job_id') |
| self._variant_targets = {key: tuple((ext_deepcopy(row) for row in rows)) for (key, rows) in variants.items()} |
| self.targets = {f'{task_id}:{int(moved)}:{index}': ext_deepcopy(target) for ((task_id, moved), targets) in variants.items() for (index, target) in enumerate(targets, 1)} |
| self._validate_target_bindings() |
| self.structure_moved = False |
| self.structure_authority = ext_deepcopy(DATA_PRE_STRUCTURE_AUTHORITY_2) |
| self.policy_epoch = 'fixed' |
| self.policy_by_cell = dict(DATA_PRE_POLICY_BY_CELL) |
| self._activated_tasks: list[str] = [] |
| self._task_targets: list[dict[str, ext_Any]] = [] |
|
|
| def _warehouse_independent_world_snapshot(self): |
| value = self._warehouse_evolution_snapshot() |
| if not getattr(self, '_restoring_independent', False): |
| value['independent_delivery_contract'] = 'warehouse-independent-deliveries-evolution-v2' |
| return value |
|
|
| def _warehouse_independent_world_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| if value.pop('independent_delivery_contract', None) != 'warehouse-independent-deliveries-evolution-v2': |
| raise ValueError('Warehouse independent snapshot version differs') |
| self._restoring_independent = True |
| try: |
| self._warehouse_evolution_restore(value) |
| finally: |
| self._restoring_independent = False |
| if self.snapshot() != snapshot: |
| raise ValueError('Warehouse independent snapshot did not round trip') |
|
|
| def _warehouse_evidence_execute_public(self, name, arguments): |
| if name == 'list_delivery_profiles': |
| return fn__success(profiles=[{'delivery_profile_id': key, **ext_deepcopy(value)} for (key, value) in DATA_DELIVERY_PROFILES.items()]) |
| if name == 'read_delivery_controls': |
| candidates = [record for record in self.control_registry.values() if all((record['scope'][key] == arguments[key] for key in arguments))] |
| return fn__success(control=ext_deepcopy(candidates[0])) |
| target = self.targets.get(arguments['request_ref']) |
| if target is None: |
| return fn__error('TARGET_SCOPE_FORBIDDEN', 'request is not in the active delivery set') |
| if name == 'find_delivery_route': |
| rows = self._directory() |
| return fn__success(candidates=[row for row in rows if row['lane_ref'] == target['delivery_lane_ref']], examined_records=len(rows)) |
| if name == 'inspect_delivery_packet': |
| result = self._inspect_delivery_packet(arguments) |
| if result['status'] == 'success': |
| result['data']['packet'].update(delivery_lane_ref=target['delivery_lane_ref'], lane_authorization=target['lane_authorization'], stable_fields=['delivery_lane_ref', 'route_id', 'lane_authorization'], task_scoped_fields=['request_ref', 'query_job_id', 'table_name', 'destination_uri']) |
| return result |
| earlier = self._task_targets[:self._task_targets.index(target)] |
| if any((not row['complete'] for row in self.grade_targets(earlier)['targets'])): |
| return fn__error('PRIOR_TARGET_INCOMPLETE', 'complete earlier listed deliveries before this request') |
| if arguments['route_id'] != target['route_id'] or arguments['lane_authorization'] != target['lane_authorization']: |
| return fn__error('DELIVERY_BINDING_MISMATCH', 'route authority does not bind this active delivery') |
| control = self.control_registry.get(arguments['control_record_id']) |
| expected_scope = {'organization_id': 'org-northshore-holdings', 'operator_role': 'warehouse_delivery_operator', 'query_priority': target['query_priority'], 'destination_classification': target['destination_classification']} |
| if control is None or control['status'] != 'approved' or control['scope'] != expected_scope: |
| return fn__error('CONTROL_SCOPE_MISMATCH', 'control is absent, unapproved, or outside the delivery scope') |
| profile = DATA_DELIVERY_PROFILES[arguments['delivery_profile_id']] |
| clause = control['clauses'] |
| if not (profile['table_type'] == clause['materialized_table_type'] and profile['format'] == clause['export_format'] and (profile['compression'] == clause['export_compression']) and (clause['quota_accounting_required'] is True)): |
| return fn__error('DELIVERY_PROFILE_MISMATCH', 'profile capabilities do not satisfy the approved control') |
| expanded = {key: target[key] for key in ('request_ref', 'route_id', 'query_job_id', 'destination_dataset_id', 'operator_user_id', 'warehouse_id', 'table_name', 'destination_uri')} |
| expanded['delivery_profile_id'] = arguments['delivery_profile_id'] |
| result = self._commit_query_delivery(expanded) |
| if result['status'] == 'success': |
| ledger = next((row for row in self.delivery_ledger if row['request_ref'] == target['request_ref'])) |
| ledger['control_record_id'] = control['control_record_id'] |
| result['data']['control_record_id'] = control['control_record_id'] |
| return result |
|
|
| def _cloud_data_warehouse_successor_business_snapshot(self): |
| return {'raw_database': self._raw_database_snapshot(), 'delivery_ledger': mod_copy.deepcopy(self.delivery_ledger), 'policy_epoch': self.policy_epoch, 'policy_by_cell': fn_canonical_policy_table(self.policy_by_cell), 'applied_boundary_events': sorted(self.applied_boundary_events)} |
|
|
| def _cloud_data_warehouse_successor_init(self, source, targets, budget=50): |
| self.source = ext_Path(source).resolve() |
| (state_manager, raw_tools) = fn__load_raw_components(str(self.source)) |
| self.raw_tools = raw_tools |
| self.raw_tools.now_iso = lambda : '2026-09-25T12:00:00Z' |
| self._runtime = mod_tempfile.TemporaryDirectory(prefix='rescope-cloud-warehouse-v2-') |
| self.manager = state_manager(str(ext_Path(self._runtime.name) / 'data')) |
| self.targets = {str(target['request_ref']): mod_copy.deepcopy(target) for target in targets} |
| if len(self.targets) != len(targets): |
| raise ValueError('request references must be unique') |
| self._seed_raw_state() |
| self.policy_epoch = 'pre' |
| self.policy_by_cell = dict(DATA_PRE_POLICY_BY_CELL) |
| self.delivery_ledger: list[dict[str, ext_Any]] = [] |
| self.applied_boundary_events: set[str] = set() |
| self.active_task_id: str | None = None |
| self.active_request_refs: set[str] = set() |
| self.initial_budget = int(budget) |
| self.work_unit_limit = int(budget) |
| self.work_units = 0 |
| self.calls = 0 |
| self.writes = 0 |
| self.receipts: list[dict[str, ext_Any]] = [] |
| self._fault: dict[str, ext_Any] | None = None |
| self._active_tool: str | None = None |
| self._mutation_count = 0 |
|
|
| def _warehouse_evolution_snapshot(self): |
| value = World._cloud_data_warehouse_successor_snapshot(self) |
| value['evolution'] = {'case_version': 'warehouse-two-event-lifecycle-evolution-v1', 'schedule': ext_deepcopy(DATA_SCHEDULE_2), 'plan_sha256': ext_digest({'rules': DATA_RULE_PLAN_2, 'structures': DATA_STRUCTURE_PLAN_2}), 'activated_tasks': list(self._activated_tasks), 'task_targets': ext_deepcopy(self._task_targets), 'structure_moved': self.structure_moved, 'own_commits': ext_deepcopy(self._own_commits)} |
| return value |
|
|
| def _warehouse_evolution_restore(self, snapshot): |
| metadata = snapshot['evolution'] |
| if metadata['case_version'] != 'warehouse-two-event-lifecycle-evolution-v1' or metadata['schedule'] != DATA_SCHEDULE_2 or metadata['plan_sha256'] != ext_digest({'rules': DATA_RULE_PLAN_2, 'structures': DATA_STRUCTURE_PLAN_2}): |
| raise ValueError('warehouse evolution contract differs') |
| active = metadata['activated_tasks'] |
| if active != list(DATA_TASK_IDS[:len(active)]) or snapshot['active_task_id'] != (active[-1] if active else None): |
| raise ValueError('warehouse evolution prefix differs') |
| events = [e['event_id'] for e in DATA_SCHEDULE_2['events'] if e['before_task'] <= len(active)] |
| if snapshot['applied_boundary_events'] != events: |
| raise ValueError('warehouse evolution event ledger differs') |
| World._cloud_data_warehouse_successor_restore(self, snapshot) |
| self.control_registry = ext_deepcopy(snapshot['control_registry']) |
| self.governance = ext_deepcopy(snapshot['governance_documents']) |
| self.structure_authority = ext_deepcopy(snapshot['structure_authority']) |
| self.structure_moved = metadata['structure_moved'] |
| self._activated_tasks = ext_deepcopy(active) |
| self._task_targets = ext_deepcopy(metadata['task_targets']) |
| self._own_commits = ext_deepcopy(metadata['own_commits']) |
| if self.snapshot() != snapshot: |
| raise ValueError('warehouse evolution did not round trip') |
|
|
| def _cloud_data_warehouse_successor_snapshot(self): |
| return {**self._business_snapshot(), 'targets': mod_copy.deepcopy(self.targets), 'active_task_id': self.active_task_id, 'active_request_refs': sorted(self.active_request_refs), 'initial_budget': self.initial_budget, 'work_unit_limit': self.work_unit_limit, 'work_units': self.work_units, 'remaining': self.remaining, 'calls': self.calls, 'writes': self.writes, 'receipts': mod_copy.deepcopy(self.receipts)} |
|
|
| def _cloud_data_warehouse_successor_restore(self, snapshot): |
| self._restore_raw_database(snapshot['raw_database']) |
| self.delivery_ledger = mod_copy.deepcopy(snapshot['delivery_ledger']) |
| self.policy_epoch = str(snapshot['policy_epoch']) |
| self.policy_by_cell = {tuple(key.split(':', 1)): value for (key, value) in snapshot['policy_by_cell'].items()} |
| self.applied_boundary_events = set(snapshot['applied_boundary_events']) |
| self.targets = mod_copy.deepcopy(snapshot['targets']) |
| self.active_task_id = snapshot['active_task_id'] |
| self.active_request_refs = set(snapshot['active_request_refs']) |
| self.initial_budget = int(snapshot['initial_budget']) |
| self.work_unit_limit = int(snapshot['work_unit_limit']) |
| self.work_units = int(snapshot['work_units']) |
| self.calls = int(snapshot['calls']) |
| self.writes = int(snapshot['writes']) |
| self.receipts = mod_copy.deepcopy(snapshot['receipts']) |
| self._fault = None |
| self._active_tool = None |
| self._mutation_count = 0 |
|
|
| class Abort(Exception): |
|
|
| def __init__(self, result): |
| Exception.__init__(self, result.get('message', 'operation rejected')) |
| self.result = result |
|
|
