#!/usr/bin/env python3 """CPU-only ISO parser benchmark. Run with Python despite the .txt extension.""" import argparse import datetime as dt import gc import hashlib import importlib.metadata import json import os from pathlib import Path import platform import statistics import subprocess import sys import tempfile import time import venv import zipfile DEPENDENCIES = [ dict(name='python-dateutil', version='2.9.0.post0', filename='python_dateutil-2.9.0.post0-py2.py3-none-any.whl', url='https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl', sha256='a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427', size=229892), dict(name='ciso8601', version='2.4.1', filename='ciso8601-2.4.1-cp314-cp314-macosx_11_0_arm64.whl', url='https://files.pythonhosted.org/packages/14/70/7da8cd683b8b5ba6617254b0e6b923ade34e8fad164802d3957cb35a55cd/ciso8601-2.4.1-cp314-cp314-macosx_11_0_arm64.whl', sha256='9633f5596aebdbf6adde84ae365eecc5b6048bdb3b63f7efe9e29025a0d989fa', size=16170), dict(name='six', version='1.17.0', filename='six-1.17.0-py2.py3-none-any.whl', url='https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl', sha256='4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274', size=11050), ] PREFIX = 'dateutil-ciso8601-local-2026-11-20-req065-a1' CYCLES = 2000 REPEATS = 9 def utc_now(): return dt.datetime.now(dt.timezone.utc).isoformat() def encode(obj): return (json.dumps(obj, ensure_ascii=False, indent=2, allow_nan=False) + '\n').encode() def representation(value): assert type(value) is dt.datetime offset = value.utcoffset() return dict(components=[value.year, value.month, value.day, value.hour, value.minute, value.second, value.microsecond], offset_seconds=None if offset is None else int(offset.total_seconds()), aware=offset is not None, iso=value.isoformat(timespec='microseconds'), utc_iso=None if offset is None else value.astimezone(dt.timezone.utc).isoformat(timespec='microseconds')) def make_cases(): # Expected values use explicit numeric constructor arguments, never either parser. walls = [ (2026, 11, 20, 12, 34, 56, 0), (2024, 2, 29, 23, 59, 59, 123456), (2000, 1, 1, 0, 0, 0, 1), (1999, 12, 31, 23, 59, 59, 999999), (2030, 6, 30, 0, 15, 30, 120000), (2025, 1, 1, 1, 2, 3, 100000), ] groups = [('utc_z', 'Z', 0), ('utc_offset', '+00:00', 0), ('positive_offset', '+09:00', 540), ('negative_offset', '-05:30', -330), ('naive', '', None)] cases = [] for group, suffix, minutes in groups: for i, parts in enumerate(walls): year, month, day, hour, minute, second, micro = parts frac = '' if micro == 0 else f'.{micro:06d}' text = f'{year:04d}-{month:02d}-{day:02d}T{hour:02d}:{minute:02d}:{second:02d}{frac}{suffix}' zone = None if minutes is None else dt.timezone(dt.timedelta(minutes=minutes)) expected = dt.datetime(*parts, tzinfo=zone) cases.append(dict(id=f'{group}-{i+1}', group=group, text=text, expected=representation(expected))) return cases def validation(parse, cases): output = [] for case in cases: actual = representation(parse(case['text'])) match = int(actual == case['expected']) assert match == 1, (case['id'], actual, case['expected']) output.append(dict(case_id=case['id'], actual=actual, expected_match=match)) return output def batch(parse, strings): gc.collect() was_enabled = gc.isenabled() gc.disable() try: start = time.perf_counter_ns() for _ in range(CYCLES): for text in strings: parse(text) # Return value discarded: reference-count disposal included. elapsed = time.perf_counter_ns() - start finally: if was_enabled: gc.enable() assert elapsed > 0 return elapsed def worker(destination): from dateutil.parser import isoparse import ciso8601 start = utc_now() load_start = os.getloadavg() parse_map = {'dateutil': isoparse, 'ciso8601': ciso8601.parse_datetime} versions = {d['name']: importlib.metadata.version(d['name']) for d in DEPENDENCIES} assert versions == {d['name']: d['version'] for d in DEPENDENCIES} cases = make_cases() groups = list(dict.fromkeys(c['group'] for c in cases)) results, warmups, order_log = [], [], [] for gi, group in enumerate(groups): subset = [c for c in cases if c['group'] == group] strings = tuple(c['text'] for c in subset) rows = {} for tool, parse in parse_map.items(): rows[tool] = dict(id=f'{group}-{tool}', group=group, tool=tool, validation_before=validation(parse, subset), trials=[]) tools = list(parse_map) if gi % 2: tools.reverse() for tool in tools: warmups.append(dict(group=group, tool=tool, elapsed_ns=batch(parse_map[tool], strings), parses=CYCLES*len(strings))) for repeat in range(REPEATS): order = tools if repeat % 2 == 0 else list(reversed(tools)) order_log.append(dict(group=group, repeat=repeat+1, order=order[:])) for tool in order: elapsed = batch(parse_map[tool], strings) rows[tool]['trials'].append(dict(repeat=repeat+1, elapsed_ns=elapsed, parses=CYCLES*len(strings), microseconds_per_parse=elapsed/(CYCLES*len(strings))/1000)) for tool, parse in parse_map.items(): rows[tool]['validation_after'] = validation(parse, subset) rows[tool]['matched_cases_after'] = sum(x['expected_match'] for x in rows[tool]['validation_after']) assert rows[tool]['matched_cases_after'] == len(subset) for a, b in zip(rows['dateutil']['validation_after'], rows['ciso8601']['validation_after'], strict=True): assert a['case_id'] == b['case_id'] and a['actual'] == b['actual'] results.extend(rows.values()) raw = dict(request_id='req-20261022-065', topic_id='dateutil-ciso8601-local-hikaku', started_utc=start, ended_utc=utc_now(), environment=dict(os=platform.platform(), python=sys.version, machine=platform.machine(), logical_cpus=os.cpu_count(), gil_enabled=sys._is_gil_enabled(), versions=versions, execution='CPU only; no GPU or Metal framework imported', load_average_start=load_start, load_average_end=os.getloadavg(), timer=vars(time.get_clock_info('perf_counter'))), conditions=dict(cycles_per_batch=CYCLES, strings_per_group=6, measured_batches_per_tool_per_group=REPEATS, warmup_batches_per_tool_per_group=1, order='alternate tools each repeat and starting tool each group', gc='cyclic GC disabled only during timed loop; refcount disposal included', scope='local valid extended ISO calendar datetimes only; no external inference or AI quality evaluation', excluded='download, install, import, input generation, validation, hashing, output I/O'), unit_map={'results[].trials[].elapsed_ns':'ns', 'results[].trials[].parses':'回', 'results[].trials[].microseconds_per_parse':'μs', 'results[].matched_cases_after':'件'}, cases=cases, warmups=warmups, order_log=order_log, results=results) dest = Path(destination) dest.mkdir() (dest / f'{PREFIX}-raw.json').write_bytes(encode(raw)) (dest / f'{PREFIX}-inputs.json').write_bytes(encode(cases)) print(json.dumps(dict(event='measurement_complete', cases=len(cases), batches=len(results)*REPEATS, all_expected_and_cross_matches=True), ensure_ascii=False)) for result in results: print(result['id'], f"{statistics.median(t['microseconds_per_parse'] for t in result['trials']):.4f}", 'us/parse') def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('--output-dir', required=True) parser.add_argument('--worker', action='store_true') args = parser.parse_args() if args.worker: worker(args.output_dir) return target = Path(args.output_dir).resolve() if target.exists(): raise FileExistsError('output-dir must be new') if (sys.version_info[:2] != (3,14) or platform.system() != 'Darwin' or platform.machine() != 'arm64' or not sys._is_gil_enabled()): raise RuntimeError('Pinned wheel requires GIL CPython 3.14 on macOS arm64') with tempfile.TemporaryDirectory(prefix='req065-iso-', dir='/tmp') as temp: temp = Path(temp) environment = temp / 'venv' venv.EnvBuilder(with_pip=False).create(environment) python = environment / 'bin/python' site = Path(subprocess.check_output([str(python), '-I', '-c', 'import sysconfig; print(sysconfig.get_path("purelib"))'], text=True).strip()) dependencies = [] for spec in DEPENDENCIES: wheel = temp / spec['filename'] subprocess.run(['curl','-q','--fail','--silent','--show-error','--location','--retry','2', spec['url'], '--output', str(wheel)], check=True) data = wheel.read_bytes() digest = hashlib.sha256(data).hexdigest() assert digest == spec['sha256'] and len(data) == spec['size'], spec['name'] with zipfile.ZipFile(wheel) as archive: for member in archive.namelist(): if Path(member).is_absolute() or '..' in Path(member).parts: raise ValueError('unsafe wheel path') archive.extractall(site) dependencies.append(dict(**spec, actual_sha256=digest, actual_size=len(data), retrieved_utc=utc_now())) stage = temp / 'results' completed = subprocess.run([str(python), '-I', str(Path(__file__).resolve()), '--worker', '--output-dir', str(stage)], check=True, text=True, capture_output=True) (stage / f'{PREFIX}-dependencies.json').write_bytes(encode(dependencies)) (stage / f'{PREFIX}-run-log.txt').write_text(completed.stdout + completed.stderr, encoding='utf-8') # Persist only successful results; all venv/wheel/staging inputs are removed on exit. target.mkdir(parents=True, exist_ok=False) for source in stage.iterdir(): (target/source.name).write_bytes(source.read_bytes()) print(completed.stdout, end='') if __name__ == '__main__': main()