Four supplied Sundays: 09:00 New York versus 13:00 UTC across autumn 2026

A fictional schedule that preserves 09:00 in America/New_York maps to 13:00Z on October 25, then 14:00Z on November 1, 8 and 15. Keeping the same dates at 13:00Z instead displays as 09:00 before the change and 08:00 afterward. The two choices agree initially and diverge by one hour after the transition. These are actual local Python conversion results, with a separately prepared expected payload.

The useful decision is temporal intent: preserve the participants' local clock time, or preserve a UTC clock time across the supplied weeks. “Fixed-UTC” here means four different instants at 13:00 UTC seven days apart, not one instant repeated. Every result includes the local date/time, zone, offset and UTC instant.

IANA tzdb 2026c's northamerica file, the US rules starting in 2007 and final America/New_York continuation, supplies the expectation: standard offset −05:00, a one-hour daylight adjustment, and the November first-Sunday return at 02:00 local time. Applying those rules puts the 2026 return on November 1. The main fixture's 09:00 is outside the repeated hour. Subtracting the displayed offsets gives the expected UTC values. The UTC separation from October 25 to November 1 is 169 hours for the wall-time schedule and 168 hours for the comparator; later pairs are 168 hours in both.

RFC 5545 §3.3.5 distinguishes UTC, local time with a zone reference, and floating values; §3.8.5.3 recommends a local-time/zone DTSTART when recurrence instances should preserve local time across zone changes. This case illustrates that intent distinction with supplied dates. It neither parses nor expands an RRULE. Its JSON has no DTSTART, COUNT, UNTIL, exclusions or edited instances; its bound is exactly the four listed dates. No serialized iCalendar validity or vendor behavior is asserted.

Python's ZoneInfo documentation explains system-data lookup and fold support. datetime.astimezone preserves the represented UTC instant during conversion. Attaching a zone is insufficient validation of a wall time: PEP 495 permits constructing invalid local datetimes. Our guard tries both fold values, converts through UTC and retains only candidates that round-trip to the supplied naive wall time. Zero distinct instants means a gap; two means ambiguity. Both are rejected, rather than selecting a resolution. This is our fixture policy, not a claim about RFC gap/fold interpretation.

This new case was authored and executed by the calendar author agent. The retained contributor draft about dateutil's spring gap was inspected to avoid duplication; its authorship and historical results are not reassigned to this case.

The profile below uses payload-reference records in both instance arrays: each record identifies a complete fence, representation, size, digest and field scope. The observed record adds an actual-run fence. Identical expected/observed bytes share one accessible payload; they remain separate expectation and execution claims.

{
  "schema": "calendar-case-v1",
  "tags": [
    "calendar",
    "recurrence",
    "timezone"
  ],
  "product": "CPython standard-library ZoneInfo conversion fixture",
  "client_version": "CPython 3.12.3; zoneinfo bundled with Python; no PyPI tzdata package installed",
  "api_or_ui": "PYTHONTZPATH=/usr/share/zoneinfo python3 check.py",
  "checked_at": "2026-10-05T01:35:25.144897Z",
  "tzdb_version": "system IANA tzdb 2026c",
  "timezone_id": "America/New_York",
  "intent": "wall-time",
  "input_fixture": {
    "description": "Four supplied Sundays, 2026-10-25 through 2026-11-15; local 09:00 versus fixed UTC 13:00. JSON conversion only; no recurrence expansion.",
    "icalendar_text": null,
    "fence": "fixture.json",
    "size_bytes": 136,
    "sha256": "2a265cad4e0bdfb32981f3becca92c41b836e20dd13800bc306c0c46edf4da35",
    "reproduction_command": "PYTHONTZPATH=/usr/share/zoneinfo python3 check.py > replay-report.json"
  },
  "expected_instances": [
    {
      "payload_fence": "expected.json",
      "format": "JSON array",
      "size_bytes": 1506,
      "sha256": "7408c78bd75b98c20e4846996a15ed4b083d7433728f7aab521ab72b2ce70bd4",
      "scope": "all eight ordered rows; every field",
      "basis": "Hand-authored UTC/local arithmetic using IANA 2026c US/New_York rules"
    }
  ],
  "observed_instances": [
    {
      "payload_fence": "expected.json",
      "format": "JSON array",
      "size_bytes": 1506,
      "sha256": "7408c78bd75b98c20e4846996a15ed4b083d7433728f7aab521ab72b2ce70bd4",
      "scope": "all eight ordered rows; every field",
      "actual_run_fence": "test-report.json",
      "observed_file": "observed.json",
      "equality": "Actual output bytes equal expected.json"
    }
  ],
  "test_status": "locally-reproduced",
  "source_locators": [
    {
      "source": "Python 3.12 zoneinfo documentation",
      "locator": "Using ZoneInfo; Data sources; Configuring the data sources",
      "url": "https://docs.python.org/3.12/library/zoneinfo.html"
    },
    {
      "source": "Python 3.12 datetime documentation",
      "locator": "datetime.astimezone",
      "url": "https://docs.python.org/3.12/library/datetime.html#datetime.datetime.astimezone"
    },
    {
      "source": "IANA tzdb 2026c northamerica",
      "locator": "Rule US 2007 max Mar Sun>=8; Nov Sun>=1; Zone America/New_York final -5:00 US continuation",
      "url": "https://data.iana.org/time-zones/tzdb-2026c/northamerica"
    },
    {
      "source": "RFC 5545",
      "locator": "3.3.5 DATE-TIME forms; 3.8.5.3 RRULE local-time recommendation",
      "url": "https://www.rfc-editor.org/rfc/rfc5545.html#section-3.3.5"
    },
    {
      "source": "PEP 495",
      "locator": "The fold attribute; Constructors; Mind the Gap",
      "url": "https://peps.python.org/pep-0495/"
    }
  ],
  "limitations": [
    "Only this eight-row positive fixture and the reported reject cases were measured.",
    "No RRULE parser/expander, iCalendar/VTIMEZONE serialization, EXDATE, edits, invitations, import or calendar service was tested.",
    "Wall-time interpretation rejects gaps/folds; it does not implement RFC resolution of these inputs.",
    "Python/tzdb upgrades or different zone files can change output. System tzdb is an external dependency, not embedded here."
  ],
  "refresh_policy": "Recheck by 2026-11-01 UTC, and sooner after Python/tzdb updates or source changes; expand scope only with separate measured fixtures."
}

Save each named fence below as a file in one disposable directory. All five files use UTF-8 without BOM, LF line endings and exactly one final LF. Preserve every character inside the fence, including the compact JSON lines. Sizes and SHA-256 identify the bytes; they do not prove execution or source authenticity.

File / fence	Bytes	SHA-256
fixture.json	136	2a265cad4e0bdfb32981f3becca92c41b836e20dd13800bc306c0c46edf4da35
convert.py	3335	11792a05d4af46f779927d0e7ee0019fa7e713cdbdea329e92159b3f1ed7042b
check.py	3635	6b30c089c327bdbe7c5857c01838b702b235338104677bd32d0c9b7532edd6a7
expected.json	1506	7408c78bd75b98c20e4846996a15ed4b083d7433728f7aab521ab72b2ce70bd4
test-report.json	2635	7027f2d96e58968938ca1b6f8f01d7325589033700ced323c5bb7abc90b71137

observed.json is generated by the checker, with the same 1506 bytes and SHA-256 as expected.json in this run. The checker writes that file, and the shell command writes a report; use a disposable directory to avoid overwriting files. No network access, calendar credentials or invitation delivery is required. Cleanup is deletion of that directory after retaining any desired outputs.

This measured Linux setup used CPython 3.12.3 and /usr/share/zoneinfo/tzdata.zi reporting 2026c. No Python tzdata package was installed. The command forces the system search directory; the measured New York TZif file was 3552 bytes with SHA-256 e9ed07d7bee0c76a9d442d091ef1f01668fee7c4f26014c0a868b19fe6c18a95. Zone bytes are an external dependency, not included in these fences. For this Linux command, install matching system data at that path; different builds may share rules without identical TZif bytes. A newer database may reproduce these rows, but that needs a new recorded run.

Execute PYTHONTZPATH=/usr/share/zoneinfo python3 check.py > replay-report.json. A successful checker exits 0. It launches convert.py fixture.json using the same interpreter, preserves actual stdout in observed.json, and requires exact expected-byte equality, empty stderr and converter exit 0. That comparison covers every field of every ordered row, including the final newline. It then executes fifteen malformed/unsupported-input cases in temporary files, requiring exit 2, no stdout and a REJECT error; the expected error text is additionally checked where supplied. The main converter emits no partial result if a later row fails.

The captured report records the actual UTC execution interval and all negative outcomes. Re-running changes timestamps in the report; its recorded digest identifies this captured run, not a deterministic future report. The positive result payload is deterministic for the stated inputs/data. Only the included main fixture was positively verified; the utility limits accepted dates to four ordered weekly dates in 2026 and the New York zone. Other accepted clocks or dates are unmeasured. The gap probe includes March 8 at 02:30; the ambiguity probe includes November 1 at 01:30. Floating times, leap seconds, other years/zones and calendar operations are outside the declared case.

fixture.json

{"timezone_id":"America/New_York","dates":["2026-10-25","2026-11-01","2026-11-08","2026-11-15"],"wall_time":"09:00","utc_time":"13:00"}

convert.py

import json
import re
import sys
from datetime import date, datetime, time, timedelta, timezone
from pathlib import Path
from zoneinfo import ZoneInfo, ZoneInfoNotFoundError

UTC = timezone.utc


def object_pairs(pairs):
    obj = {}
    for key, value in pairs:
        if key in obj:
            raise ValueError("duplicate field")
        obj[key] = value
    return obj


def clock(value):
    if not isinstance(value, str) or not re.fullmatch(r"[0-9]{2}:[0-9]{2}", value):
        raise ValueError("clock format")
    return time.fromisoformat(value)


def unique_wall(naive, zone):
    candidates = {}
    for fold in (0, 1):
        aware = naive.replace(tzinfo=zone, fold=fold)
        instant = aware.astimezone(UTC)
        if instant.astimezone(zone).replace(tzinfo=None) == naive:
            candidates[instant] = aware
    if not candidates:
        raise ValueError("nonexistent wall time")
    if len(candidates) != 1:
        raise ValueError("ambiguous wall time")
    return next(iter(candidates)).astimezone(zone)


def convert(obj):
    if not isinstance(obj, dict) or set(obj) != {
        "timezone_id", "dates", "wall_time", "utc_time"
    }:
        raise ValueError("fixture fields")
    key = obj["timezone_id"]
    if not isinstance(key, str) or not key:
        raise ValueError("zone key")
    try:
        zone = ZoneInfo(key)
    except ZoneInfoNotFoundError:
        raise ValueError("zone unavailable") from None
    if key != "America/New_York":
        raise ValueError("unsupported zone")
    raw_dates = obj["dates"]
    if not isinstance(raw_dates, list) or len(raw_dates) != 4:
        raise ValueError("four dates required")
    dates = []
    for value in raw_dates:
        if not isinstance(value, str) or not re.fullmatch(r"[0-9]{4}-[0-9]{2}-[0-9]{2}", value):
            raise ValueError("date format")
        dates.append(date.fromisoformat(value))
    if any(day.year != 2026 for day in dates):
        raise ValueError("only 2026 supported")
    if any(b - a != timedelta(days=7) for a, b in zip(dates, dates[1:])):
        raise ValueError("weekly ordered dates required")
    wall_clock, utc_clock = clock(obj["wall_time"]), clock(obj["utc_time"])
    rows = []
    for day in dates:
        wall = unique_wall(datetime.combine(day, wall_clock), zone)
        fixed = datetime.combine(day, utc_clock, UTC).astimezone(zone)
        for label, local in (("wall-time", wall), ("fixed-UTC", fixed)):
            rows.append({
                "schedule": label,
                "input_date": day.isoformat(),
                "local_datetime": local.isoformat(),
                "timezone_id": key,
                "utc_offset": local.isoformat()[-6:],
                "utc_instant": local.astimezone(UTC).isoformat().replace("+00:00", "Z")
            })
    return rows


def encode(rows):
    return (json.dumps(rows, separators=(",", ":")) + "\n").encode("utf-8")


if __name__ == "__main__":
    try:
        if len(sys.argv) != 2:
            raise ValueError("usage: convert.py fixture.json")
        obj = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"), object_pairs_hook=object_pairs)
        sys.stdout.buffer.write(encode(convert(obj)))
    except (ValueError, TypeError, OSError) as error:
        print("REJECT: " + str(error), file=sys.stderr)
        sys.exit(2)

check.py

import hashlib
import json
import os
import platform
import subprocess
import sys
import tempfile
from datetime import datetime, timezone
from pathlib import Path

base = Path(__file__).resolve().parent
started = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
environment = dict(os.environ, PYTHONTZPATH="/usr/share/zoneinfo")


def run(path):
    return subprocess.run([sys.executable, str(base / "convert.py"), str(path)],
                          env=environment, capture_output=True)


fixture = json.loads((base / "fixture.json").read_bytes())
expected = (base / "expected.json").read_bytes()
result = run(base / "fixture.json")
(base / "observed.json").write_bytes(result.stdout)
if result.returncode != 0 or result.stderr or result.stdout != expected:
    raise RuntimeError("positive output mismatch or execution error")
rows = json.loads(result.stdout)
negative = []


def reject(label, payload, message=None):
    with tempfile.TemporaryDirectory() as directory:
        path = Path(directory) / "bad.json"
        path.write_bytes(payload)
        output = run(path)
    if output.returncode != 2 or output.stdout or not output.stderr.startswith(b"REJECT: "):
        raise RuntimeError("failed rejection: " + label)
    stderr = output.stderr.decode().strip()
    if message and stderr != "REJECT: " + message:
        raise RuntimeError("wrong rejection: " + label)
    negative.append({"case": label, "exit": 2, "stdout_bytes": 0, "stderr": stderr})


reject("malformed-json", b"{", None)
reject("duplicate-field", b'{"dates":[],"dates":[]}', "duplicate field")
cases = [
    ("missing-zone", {k: v for k, v in fixture.items() if k != "timezone_id"}, "fixture fields"),
    ("unavailable-zone", dict(fixture, timezone_id="NoSuchCalendarZone/Fixture"), "zone unavailable"),
    ("empty-zone", dict(fixture, timezone_id=""), "zone key"),
    ("unsupported-zone", dict(fixture, timezone_id="UTC"), "unsupported zone"),
    ("extra-field", dict(fixture, count=4), "fixture fields"),
    ("invalid-clock", dict(fixture, wall_time="24:00"), None),
    ("offset-clock", dict(fixture, wall_time="09:00-04:00"), "clock format"),
    ("wrong-clock-type", dict(fixture, utc_time=13), "clock format"),
    ("short-dates", dict(fixture, dates=fixture["dates"][:3]), "four dates required"),
    ("invalid-date", dict(fixture, dates=["2026-02-30"] * 4), None),
    ("unordered-dates", dict(fixture, dates=list(reversed(fixture["dates"]))), "weekly ordered dates required"),
    ("gap", dict(fixture, dates=["2026-03-01", "2026-03-08", "2026-03-15", "2026-03-22"], wall_time="02:30"), "nonexistent wall time"),
    ("fold", dict(fixture, wall_time="01:30"), "ambiguous wall time")
]
for label, payload, message in cases:
    reject(label, (json.dumps(payload) + "\n").encode(), message)
report = {
    "started_at": started,
    "finished_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
    "python": platform.python_version(),
    "tzdb": Path("/usr/share/zoneinfo/tzdata.zi").read_text().splitlines()[0],
    "zone_file_sha256": hashlib.sha256(Path("/usr/share/zoneinfo/America/New_York").read_bytes()).hexdigest(),
    "command": "PYTHONTZPATH=/usr/share/zoneinfo python3 check.py",
    "positive_exit": result.returncode,
    "positive_stderr_bytes": len(result.stderr),
    "ordered_rows": len(rows),
    "comparison": "All six fields in each of eight ordered rows equal expected.json; bytes equal including final LF",
    "observed_bytes": len(result.stdout),
    "observed_sha256": hashlib.sha256(result.stdout).hexdigest(),
    "negative_cases": negative
}
print(json.dumps(report, indent=2))

expected.json

[{"schedule":"wall-time","input_date":"2026-10-25","local_datetime":"2026-10-25T09:00:00-04:00","timezone_id":"America/New_York","utc_offset":"-04:00","utc_instant":"2026-10-25T13:00:00Z"},{"schedule":"fixed-UTC","input_date":"2026-10-25","local_datetime":"2026-10-25T09:00:00-04:00","timezone_id":"America/New_York","utc_offset":"-04:00","utc_instant":"2026-10-25T13:00:00Z"},{"schedule":"wall-time","input_date":"2026-11-01","local_datetime":"2026-11-01T09:00:00-05:00","timezone_id":"America/New_York","utc_offset":"-05:00","utc_instant":"2026-11-01T14:00:00Z"},{"schedule":"fixed-UTC","input_date":"2026-11-01","local_datetime":"2026-11-01T08:00:00-05:00","timezone_id":"America/New_York","utc_offset":"-05:00","utc_instant":"2026-11-01T13:00:00Z"},{"schedule":"wall-time","input_date":"2026-11-08","local_datetime":"2026-11-08T09:00:00-05:00","timezone_id":"America/New_York","utc_offset":"-05:00","utc_instant":"2026-11-08T14:00:00Z"},{"schedule":"fixed-UTC","input_date":"2026-11-08","local_datetime":"2026-11-08T08:00:00-05:00","timezone_id":"America/New_York","utc_offset":"-05:00","utc_instant":"2026-11-08T13:00:00Z"},{"schedule":"wall-time","input_date":"2026-11-15","local_datetime":"2026-11-15T09:00:00-05:00","timezone_id":"America/New_York","utc_offset":"-05:00","utc_instant":"2026-11-15T14:00:00Z"},{"schedule":"fixed-UTC","input_date":"2026-11-15","local_datetime":"2026-11-15T08:00:00-05:00","timezone_id":"America/New_York","utc_offset":"-05:00","utc_instant":"2026-11-15T13:00:00Z"}]

test-report.json

{
  "started_at": "2026-10-05T01:35:24.119934Z",
  "finished_at": "2026-10-05T01:35:25.144897Z",
  "python": "3.12.3",
  "tzdb": "# version 2026c",
  "zone_file_sha256": "e9ed07d7bee0c76a9d442d091ef1f01668fee7c4f26014c0a868b19fe6c18a95",
  "command": "PYTHONTZPATH=/usr/share/zoneinfo python3 check.py",
  "positive_exit": 0,
  "positive_stderr_bytes": 0,
  "ordered_rows": 8,
  "comparison": "All six fields in each of eight ordered rows equal expected.json; bytes equal including final LF",
  "observed_bytes": 1506,
  "observed_sha256": "7408c78bd75b98c20e4846996a15ed4b083d7433728f7aab521ab72b2ce70bd4",
  "negative_cases": [
    {
      "case": "malformed-json",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)"
    },
    {
      "case": "duplicate-field",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: duplicate field"
    },
    {
      "case": "missing-zone",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: fixture fields"
    },
    {
      "case": "unavailable-zone",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: zone unavailable"
    },
    {
      "case": "empty-zone",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: zone key"
    },
    {
      "case": "unsupported-zone",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: unsupported zone"
    },
    {
      "case": "extra-field",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: fixture fields"
    },
    {
      "case": "invalid-clock",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: hour must be in 0..23"
    },
    {
      "case": "offset-clock",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: clock format"
    },
    {
      "case": "wrong-clock-type",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: clock format"
    },
    {
      "case": "short-dates",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: four dates required"
    },
    {
      "case": "invalid-date",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: day is out of range for month"
    },
    {
      "case": "unordered-dates",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: weekly ordered dates required"
    },
    {
      "case": "gap",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: nonexistent wall time"
    },
    {
      "case": "fold",
      "exit": 2,
      "stdout_bytes": 0,
      "stderr": "REJECT: ambiguous wall time"
    }
  ]
}