# Alterna AI chapter 20: verified standalone examples
def validate_request_20a(value_20a):
    if not isinstance(value_20a, dict) or set(value_20a) != {'prompt', 'max_new_tokens'}:
        return False
    limit_20a = value_20a['max_new_tokens']
    return (isinstance(value_20a['prompt'], str) and
            isinstance(limit_20a, int) and not isinstance(limit_20a, bool) and
            1 <= limit_20a <= 8)

request_20a = {'prompt': 'Объясни результат', 'max_new_tokens': 4}
assert validate_request_20a(request_20a)
assert not validate_request_20a({'prompt': 'x', 'max_new_tokens': True})
assert not validate_request_20a({'prompt': 'x', 'max_new_tokens': 2, 'debug': True})


from hashlib import sha256

sample_ids_20b = [f'sample-{index_20b}' for index_20b in range(12)]
def split_name_20b(identifier_20b):
    bucket_20b = int(sha256(identifier_20b.encode('utf-8')).hexdigest(), 16) % 4
    return 'validation' if bucket_20b == 0 else 'train'

assignments_20b = {item_20b: split_name_20b(item_20b) for item_20b in sample_ids_20b}
train_20b = {item_20b for item_20b in sample_ids_20b if split_name_20b(item_20b) == 'train'}
validation_20b = set(sample_ids_20b) - train_20b
assert train_20b and validation_20b and train_20b.isdisjoint(validation_20b)
assert train_20b | validation_20b == set(sample_ids_20b)
assert assignments_20b == {item_20b: split_name_20b(item_20b) for item_20b in reversed(sample_ids_20b)}


from random import Random

def generate_20c(seed_20c, maximum_20c=4):
    rng_20c = Random(seed_20c)
    choices_20c = [('A', 0.5), ('B', 0.3), ('<eos>', 0.2)]
    output_20c = []
    for _step_20c in range(maximum_20c):
        draw_20c, cumulative_20c = rng_20c.random(), 0.0
        selected_20c = choices_20c[-1][0]
        for token_20c, probability_20c in choices_20c:
            cumulative_20c += probability_20c
            if draw_20c < cumulative_20c:
                selected_20c = token_20c
                break
        if selected_20c == '<eos>':
            return output_20c, 'eos'
        output_20c.append(selected_20c)
    return output_20c, 'length'

tokens_20c, stop_20c = generate_20c(7)
assert (tokens_20c, stop_20c) == (['A', 'A', 'B', 'A'], 'length')
assert generate_20c(7) == (tokens_20c, stop_20c)


claims_20d = [('Модель имеет две версии', 'd1'), ('Пакет содержит manifest', 'd2'), ('Latency всегда мала', None)]
allowed_sources_20d = {'d1', 'd2'}
supported_20d = [source_20d in allowed_sources_20d for _claim_20d, source_20d in claims_20d]
coverage_20d = sum(supported_20d) / len(claims_20d) if claims_20d else 1.0
empty_claims_20d = []
empty_coverage_20d = sum(empty_claims_20d) / len(empty_claims_20d) if empty_claims_20d else 1.0
assert supported_20d == [True, True, False]
assert abs(coverage_20d - 2 / 3) < 1e-12
assert empty_coverage_20d == 1.0


thresholds_20e = {'quality': 0.80, 'grounding': 0.85, 'p95': 0.80, 'unsafe': 0.01}
metrics_20e = {'quality': 0.82, 'grounding': 0.90, 'p95': 0.70, 'unsafe': 0.00}
checks_20e = {
    'quality': metrics_20e['quality'] >= thresholds_20e['quality'],
    'grounding': metrics_20e['grounding'] >= thresholds_20e['grounding'],
    'p95': metrics_20e['p95'] <= thresholds_20e['p95'],
    'unsafe': metrics_20e['unsafe'] <= thresholds_20e['unsafe'],
}
assert all(checks_20e.values())
failing_20e = dict(metrics_20e, unsafe=0.02)
assert not (failing_20e['unsafe'] <= thresholds_20e['unsafe'])


from hashlib import sha256
from json import dumps

model_bytes_20f = b'model-v1'
manifest_20f = {
    'schema_version': 1,
    'files': {'model.bin': sha256(model_bytes_20f).hexdigest()},
    'runtime': {'name': 'local-stdlib-fixture', 'opset': 1},
}
canonical_20f = dumps(manifest_20f, sort_keys=True, separators=(',', ':'), ensure_ascii=True).encode('utf-8')
manifest_digest_20f = sha256(canonical_20f).hexdigest()
assert manifest_20f['files']['model.bin'] == sha256(model_bytes_20f).hexdigest()
assert sha256(b'model-v1').hexdigest() != sha256(b'model-v2').hexdigest()
assert manifest_digest_20f == sha256(canonical_20f).hexdigest()

print('Chapter 20: 6 examples PASS')