Performance and cost: measure capacity and useful outcomes

"""Original closed-batch accounting exercise, not billing or transaction software."""
from copy import deepcopy
from fractions import Fraction
import hashlib
import itertools
import json
from pathlib import Path


def integer(value, label):
 if type(value) is not int or value < 0:
 raise ValueError(label + ' must be a nonnegative integer')
 return value


def summarize(cost_cents, expected, attempts, deadline, costs_complete=True):
 integer(cost_cents, 'cost_cents'); integer(deadline, 'deadline')
 if type(costs_complete) is not bool:
 raise ValueError('costs_complete must be boolean')
 if not isinstance(expected, list) or not expected or any(type(x) is not str or not x for x in expected) or len(set(expected))!= len(expected):
 raise ValueError('expected IDs must be unique nonempty strings')
 if not isinstance(attempts, list):
 raise ValueError('attempts must be a list')
 wanted, useful, outside, occurrences = set(expected), set, set, {}
 for row in attempts:
 if not isinstance(row, dict) or set(row)!= {'operation', 'valid', 'completedAt'}:
 raise ValueError('invalid attempt shape')
 if type(row['operation']) is not str or not row['operation'] or type(row['valid']) is not bool:
 raise ValueError('invalid attempt identity or validity')
 integer(row['completedAt'], 'completedAt')
 key = row['operation']
 if key not in wanted:
 outside.add(key)
 elif row['valid'] and row['completedAt'] <= deadline:
 useful.add(key)
 occurrences[key] = occurrences.get(key, 0) + 1
 return {'recordedCostCents': cost_cents, 'costsComplete': costs_complete,
 'attemptRows': len(attempts), 'usefulCount': len(useful),
 'costPerUsefulCents': str(Fraction(cost_cents, len(useful))) if useful and costs_complete else None,
 'usefulIds': sorted(useful), 'missingIds': sorted(wanted - useful),
 'outsideScopeIds': sorted(outside),
 'repeatedUsefulIds': sorted(k for k, n in occurrences.items if n > 1),
 'meetsRequiredVolume': useful == wanted, 'optimizationApproved': False}


def row(key, valid=True, time=100):
 return {'operation': key, 'valid': valid, 'completedAt': time}


def main:
 expected = ['op-' + str(n) for n in range(1000)]
 a = [row(k) for k in expected] + [row(expected[i], False) for i in range(200)]
 b = [row(k) for k in expected[:600]] + [row(expected[i % 600], False) for i in range(900)]
 definitions = [
 ('plan-a', 15000, expected, a, 100, True, 1000, '15'),
 ('plan-b', 12000, expected, b, 100, True, 600, '20'),
 ('duplicate-row', 120, ['a', 'b'], [row('a'), row('a'), row('b')], 100, True, 2, '60'),
 ('zero-useful', 5000, ['a'], [row('a', False)], 100, True, 0, None),
 ('late-or-invalid', 200, ['a', 'b', 'c'], [row('a'), row('b', True, 101), row('c', False)], 100, True, 1, '200'),
 ('outside-scope', 200, ['a', 'b'], [row('a'), row('x')], 100, True, 1, '200'),
 ('incomplete-cost', 100, ['a'], [row('a')], 100, False, 1, None),
 ('deadline-boundary', 123, ['a'], [row('a', True, 100)], 100, True, 1, '123'),
 ]
 fixtures = []
 for name, cost, wanted, attempts, deadline, complete, count, unit in definitions:
 before = deepcopy((wanted, attempts))
 result = summarize(cost, wanted, attempts, deadline, complete)
 assert result['usefulCount'] == count and result['costPerUsefulCents'] == unit
 assert (wanted, attempts) == before
 # Keep evidence compact; full IDs remain available from summarize.
 compact = {k: v for k, v in result.items if k not in ['usefulIds', 'missingIds']}
 compact['missingCount'] = len(result['missingIds'])
 fixtures.append({'id': name, **compact})
 checks = 0
 small = ['a', 'b', 'c', 'd', 'e', 'f']
 for mask, duplicates in itertools.product(range(64), repeat=2):
 attempts = [row(k) for i, k in enumerate(small) if mask & (1 << i)]
 attempts += [row(k) for i, k in enumerate(small) if mask & duplicates & (1 << i)]
 result = summarize(120, small, attempts, 100)
 count = mask.bit_count
 assert result['usefulCount'] == count
 assert result['costPerUsefulCents'] == (str(Fraction(120, count)) if count else None)
 assert len(result['repeatedUsefulIds']) == (mask & duplicates).bit_count
 assert len(result['missingIds']) == 6 - count
 checks += 1
 invalid = [(-1, ['a'], [], 100), (True, ['a'], [], 100), (1, [], [], 100),
 (1, ['a', 'a'], [], 100), (1, [''], [], 100), (1, ['a'], {}, 100),
 (1, ['a'], [{}], 100), (1, ['a'], [row('a', 1)], 100),
 (1, ['a'], [row('a', True, -1)], 100), (1, ['a'], [], 1.5)]
 for args in invalid:
 try:
 summarize(*args)
 except ValueError:
 pass
 else:
 raise AssertionError('invalid input accepted')
 print(json.dumps({'scriptSha256': hashlib.sha256(Path(__file__).read_bytes).hexdigest,
 'fixtures': fixtures, 'identityCombinations': checks, 'invalidInputs': len(invalid),
 'inputPreserved': True, 'cloudExecuted': False, 'billingApiCalled': False,
 'network': False, 'persistentWrites': False,
 'limitations': 'Fictional complete-scope costs and supplied validity; repeated rows flagged, no proof or repair of financial effects, no optimization authorization.'}, indent=2))


if __name__ == '__main__':
 main

Related topics: Queue recovery and reconciliation · Promotion signals and comparable populations · Commitments, reservations and cost scope

Reference: Professional Cloud DevOps Engineer exam guide · Current linked guide; edition date unconfirmed (2026-09-30 inspection)