Download scripts/generate.py from drewgrant616/7deadlysinstest: direct link, hf CLI and curl.
- Browser
- Download file 11.4 kB
-
https://huggingface.co/datasets/drewgrant616/7deadlysinstest/resolve/main/scripts/generate.py
- Command line
-
hf download hf://datasets/drewgrant616/7deadlysinstest/scripts/generate.py
-
curl -L -o generate.py https://huggingface.co/datasets/drewgrant616/7deadlysinstest/resolve/main/scripts/generate.py
11.4 kB
| """Deterministic standalone exporter. Python 3.10+, standard library only.""" | |
| import json | |
| from pathlib import Path | |
| BASE = Path(__file__).resolve().parents[1] | |
| SNAPSHOT = json.loads((BASE / 'source/snapshot.json').read_text(encoding='utf-8')) | |
| IDS = [s['id'] for s in SNAPSHOT['dimensions']] | |
| def classify(scores): | |
| ranked = sorted(scores, key=lambda s: -s['value']) # stable source order | |
| top = ranked[0]['value'] | |
| if all(s['value'] < 25 for s in scores): | |
| return {'title': 'A quieter side', 'leaders': []} | |
| if all(s['value'] >= 75 for s in scores): | |
| return {'title': 'Many sides, strongly felt', 'leaders': []} | |
| if top - ranked[-1]['value'] <= 12.5: | |
| return {'title': 'An even constellation', 'leaders': []} | |
| if top < 50: | |
| return {'title': 'No strong leading side', 'leaders': []} | |
| leaders = [s['id'] for s in ranked if top - s['value'] <= 6.25] | |
| return {'title': 'A little more complex' if len(leaders) > 2 else ' + '.join(x.title() for x in leaders), 'leaders': leaders} | |
| def score(items, answers, minimum): | |
| scores, ranges = [], [] | |
| for sid in IDS: | |
| group = [q for q in items if q['dimension_id'] == sid] | |
| values = [4-answers[q['question_id']] if q['reverse'] else answers[q['question_id']] | |
| for q in group if type(answers.get(q['question_id'])) is int and 0 <= answers[q['question_id']] <= 4] | |
| count, total = len(values), sum(values) | |
| scores.append({'id': sid, 'value': total/count*25 if count else 0, 'count': count}) | |
| ranges.append({'id': sid, 'low': total/len(group)*25, | |
| 'high': (total+4*(len(group)-count))/len(group)*25}) | |
| coverage = all(s['count'] >= minimum for s in scores) | |
| checked = changed = 0 | |
| profile = classify(scores) | |
| if coverage: | |
| for q in items: | |
| raw = answers.get(q['question_id']) | |
| if type(raw) is not int or not 0 <= raw <= 4: | |
| continue | |
| for delta in [-1, 1]: | |
| if 0 <= raw+delta <= 4: | |
| candidate = [dict(s) for s in scores] | |
| j = IDS.index(q['dimension_id']) | |
| # Recompute the affected mean, preserving JS arithmetic order. | |
| group = [x for x in items if x['dimension_id'] == q['dimension_id']] | |
| changed_answers = {**answers, q['question_id']: raw+delta} | |
| vals = [4-changed_answers[x['question_id']] if x['reverse'] else changed_answers[x['question_id']] | |
| for x in group if type(changed_answers.get(x['question_id'])) is int and 0 <= changed_answers[x['question_id']] <= 4] | |
| candidate[j]['value'] = sum(vals)/len(vals)*25 | |
| checked += 1 | |
| changed += classify(candidate)['title'] != profile['title'] | |
| top = max(s['value'] for s in scores) | |
| tied = [s for s in scores if abs(s['value']-top) < 1e-8] | |
| character_id = 'quiet' if top == 0 else tied[0]['id'] if len(tied) == 1 else 'balanced' if profile['title'] in ['An even constellation', 'No strong leading side'] else 'mixed' | |
| character = {'id': character_id, 'name': SNAPSHOT['characters'][character_id]['name'], | |
| 'title': character_id.title() if character_id in IDS else 'Drama-free' if character_id == 'quiet' else 'A glorious mix'} | |
| return {'scores': scores, 'computed_profile': profile, 'computed_character':character, 'coverage_complete': coverage, | |
| 'possible_completed_ranges': ranges, 'sensitivity': {'checked': checked, 'changed': changed}} | |
| def write_jsonl(name, rows): | |
| target = BASE / 'data' / f'{name}.jsonl' | |
| target.parent.mkdir(exist_ok=True) | |
| target.write_text(''.join(json.dumps(row, ensure_ascii=False, separators=(',', ':'), allow_nan=False)+'\n' for row in rows), encoding='utf-8', newline='\n') | |
| def build(): | |
| taxonomy = [dict(s, character_name=SNAPSHOT['characters'][s['id']]['name'], source_path='src/shared/quiz/quiz.ts') for s in SNAPSHOT['dimensions']] | |
| rules = [ | |
| ('answer-domain', 'input', 'integer 0 through 4; null is an addressed skip', 'Exclude missing or invalid values from means.'), | |
| ('direct', 'item', 'reverse == false', 'adjusted = raw'), | |
| ('reverse', 'item', 'reverse == true', 'adjusted = 4 - raw'), | |
| ('mean', 'dimension', 'count > 0', 'value = sum(adjusted) / count * 25; preserve precision'), | |
| ('empty', 'dimension', 'count == 0', 'value = 0; count = 0; not an observed low tendency'), | |
| ('quiet', 'classification', 'all values < 25', 'A quieter side'), | |
| ('broad', 'classification', 'all values >= 75', 'Many sides, strongly felt'), | |
| ('even', 'classification', 'max - min <= 12.5', 'An even constellation'), | |
| ('weak', 'classification', 'max < 50', 'No strong leading side'), | |
| ('leaders', 'classification', 'otherwise', 'Select every dimension within 6.25 of max; stable descending sort'), | |
| ('complex', 'classification', 'more than two selected leaders', 'A little more complex; retain all leader IDs'), | |
| ('coverage', 'eligibility', 'quick >= 2; full >= 8 usable answers per dimension', 'Require every dimension to reach its minimum'), | |
| ('full-visited', 'eligibility', 'full mode', 'Also require all 70 questions addressed; null counts as addressed'), | |
| ('range', 'explanation', 'N items; n usable; adjusted sum S', 'low = S/N*25; high = (S+4*(N-n))/N*25; not confidence intervals'), | |
| ('sensitivity', 'explanation', 'coverage complete', 'Change each valid raw answer by one permitted step separately; count title changes, not probabilities'), | |
| ('character', 'presentation', 'zero maximum -> quiet; unique exact maximum -> dimension; otherwise title mapping', 'UI character uses exact top ties (tolerance 1e-8), separately from the analytical 6.25 leader window'), | |
| ] | |
| rules = [{'id': rid, 'position': i+1, 'scope': scope, 'condition': cond, 'action': action, | |
| 'source_path': 'src/shared/quiz/characters.ts' if rid == 'character' else 'src/components/seven-sides/FullTest.tsx' if rid == 'full-visited' else 'src/shared/quiz/analysis.ts' if rid in ['range','sensitivity'] else 'src/shared/quiz/full-quiz.ts' if rid == 'coverage' else 'src/shared/quiz/quiz.ts', | |
| 'classification_precedence': ['quiet','broad','even','weak','leaders','complex'].index(rid)+1 if rid in ['quiet','broad','even','weak','leaders','complex'] else 0} | |
| for i, (rid, scope, cond, action) in enumerate(rules)] | |
| cases = [] | |
| for mode in SNAPSHOT['modes']: | |
| items = [q for q in SNAPSHOT['questions'] if q['mode'] == mode['id']] | |
| def fixture(values): | |
| return {q['question_id']: 4-values[IDS.index(q['dimension_id'])] if q['reverse'] else values[IDS.index(q['dimension_id'])] for q in items} | |
| def add(name, purpose, answers): | |
| out = score(items, answers, mode['minimum']) | |
| addressed = sum(q['question_id'] in answers for q in items) | |
| cases.append({'id': f"{mode['id']}:{name}", 'mode': mode['id'], 'version': mode['version'], | |
| 'purpose': purpose, 'synthetic': True, | |
| 'answers': [{'question_id': q['question_id'], 'raw': answers[q['question_id']]} for q in items if q['question_id'] in answers], | |
| 'addressed_count': addressed, 'minimum_per_dimension': mode['minimum'], | |
| **out, 'result_eligible': out['coverage_complete'] and (mode['id'] == 'quick' or addressed == len(items))}) | |
| for value in range(5): | |
| add(f'adjusted-uniform-{value}', 'Uniform adjusted response; exercises low, even or broad classification.', fixture([value]*7)) | |
| for j, sid in enumerate(IDS): | |
| values = [1]*7 | |
| values[j] = 4 | |
| add(f'leader-{sid}', 'Each dimension can be a unique leader.', fixture(values)) | |
| values[(j+1) % 7] = 4 | |
| add(f'tie-{sid}-{IDS[(j+1)%7]}', 'Two equal leaders retain taxonomy order.', fixture(values)) | |
| add('three-leaders', 'More than two leaders has a descriptive complex title.', fixture([4,4,4,1,1,1,1])) | |
| add('no-strong-leader', 'Uneven scores can remain below the leading threshold.', fixture([1,0,0,0,0,0,0])) | |
| for value in range(5): | |
| if value == 2: # midpoint already represented by adjusted-uniform-2 | |
| continue | |
| a = fixture([2]*7) | |
| a[items[0]['question_id']] = value | |
| add(f'direct-sweep-{value}', 'Direct item sensitivity across the entire response scale.', a) | |
| a = fixture([2]*7) | |
| a[next(q['question_id'] for q in items if q['reverse'])] = value | |
| add(f'reverse-sweep-{value}', 'Reverse item sensitivity across the entire response scale.', a) | |
| a = fixture([2]*7) | |
| pride = [q for q in items if q['dimension_id'] == 'pride'] | |
| a[pride[0]['question_id']] = 4 | |
| a[pride[1]['question_id']] = 0 | |
| add('same-mean-mixed', 'Same mean as midpoint responses; different item evidence.', a) | |
| a = fixture([2]*7) | |
| for sid in IDS: | |
| group = [q for q in items if q['dimension_id'] == sid] | |
| for q in group[mode['minimum']:]: | |
| a[q['question_id']] = None | |
| add('minimum-with-skips', 'Exactly sufficient coverage in every group; missing-answer ranges.', a) | |
| a[items[0]['question_id']] = None | |
| add('below-minimum', 'One dimension lacks coverage; no eligible result or sensitivity checks.', a) | |
| a = fixture([2]*7) | |
| del a[pride[-1]['question_id']] | |
| add('unaddressed', 'Distinguish an omitted question from an explicit null skip.', a) | |
| add('empty', 'Zero placeholder scores never constitute an eligible observed profile.', {}) | |
| add('all-skipped', 'All questions addressed but no usable responses.', {q['question_id']:None for q in items}) | |
| if mode['id'] == 'quick': | |
| add('website-sample', 'Existing website sample, not a real respondent.', SNAPSHOT['sample_answers']) | |
| classifier = [] | |
| vectors = [ | |
| ('below-25', [24.999]*7), ('at-25', [25]*7), | |
| ('below-75', [74.999]*7), ('at-75', [75]*7), | |
| ('spread-at-12-5', [62.5,50,50,50,50,50,50]), | |
| ('spread-above-12-5', [62.501,50,50,50,50,50,50]), | |
| ('top-below-50', [49.999,0,0,0,0,0,0]), ('top-at-50', [50,0,0,0,0,0,0]), | |
| ('tie-at-6-25', [75,68.75,0,0,0,0,0]), ('tie-outside-6-25', [75,68.749,0,0,0,0,0]), | |
| ('stable-source-order', [0,80,80,0,0,0,0]), ('three-leaders', [80,80,80,0,0,0,0]), | |
| ('quiet-before-even', [10]*7), ('broad-before-even', [90]*7), | |
| ] | |
| for name, values in vectors: | |
| scores = [{'id':sid,'value':value,'count':0} for sid,value in zip(IDS, values)] | |
| classifier.append({'id': f'classifier:{name}', 'synthetic':True, 'input_space':'arbitrary_score_vectors_not_questionnaire_attempts', | |
| 'scores': scores, 'expected_profile': classify(scores)}) | |
| return {'taxonomy':taxonomy, 'questions':SNAPSHOT['questions'], 'rules':rules, 'scoring_cases':cases, 'classification_cases':classifier} | |
| if __name__ == '__main__': | |
| from schema_types import DOCUMENT | |
| for name, rows in build().items(): | |
| write_jsonl(name, rows) | |
| print(f'{name}: {len(rows)} rows') | |
| (BASE / 'schema.json').write_text(json.dumps(DOCUMENT, indent=2)+'\n', encoding='utf-8', newline='\n') | |