diff --git a/PROGRESS.md b/PROGRESS.md index 26471a821..cabe4df34 100644 --- a/PROGRESS.md +++ b/PROGRESS.md @@ -1,3 +1,225 @@ +# Retention: replay by content seal, not by retained population + +Lane: `native-retention-seal`, off `origin/native-scale-transport` at +`a64f7b733`, worktree `~/PolicyEngine/_worktrees/microcosm-native-retention`. +Started 2026-09-17. Everything below the `---` rule at the end of this section +is prior-lane history; see "Root journals are history, not state" in +`CLAUDE.md`. + +## State + +Implemented; both required runs have run. The 1/1000 cold run **and its +required replay completed** and export byte-identical bytes (identical manifest +key, 0 store paths added or changed), at 1,714.92 CPU-s against the transport +after-run's 1,907.58. The **1/15 run refused** 605.65 CPU-s in, at 8.28 GB, +having run no node: `PREPARATION_ISSUANCE_REFUSED`, the catch-all that discards +its cause. The predicted cause is a 1 MiB canonical-JSON cap on the +selected-ACS-`SERIALNO` list — **below** the row-count ceiling the base branch +lifted, and in no census — and a non-invasive 1/15 diagnostic is running to +name it rather than infer it. The discrimination battery is 116 comparisons, +116 agreements, 0 disagreements. Draft PR #950 is open and stays draft. + +## Done + +- Verified worktree/branch/head; synced `uv sync --all-packages --locked --extra us`. +- Read both authorities in full and the code at this head. +- `docs/us-native-retention-seal.md` — the four required answers. +- `survey_population_replay.py` — the purpose-built seal, beside the + comparison it replaces. +- `test_us_survey_population_replay.py` — every mutation now runs through BOTH + the object comparison and the seal, and must reach the same verdict with the + same code; plus the discriminations the first battery missed. +- `executor.py` — `run_graph(_population_observer_detach=False)`, its own + commit, four tests, no US import. +- `graph_atomic_survey_financial.py` — declared-consumer retention, both + comparisons sealed, `_node_population_stamp` on both arms. +- Repaired a **stale implementation contract inherited from the transport + branch** and added the guard that would have caught it. +- Armed both runs with their gates and their source trees, and ran both. +- The 1/1000 cold run plus required replay, under a byte-identical copy of the + transport lane's committed harness: `COMPLETED_NINETEEN_NODE_AND_REQUIRED_REPLAY`, + every node a store hit on the replay, manifest key identical, store bytes + identical. Recorded with the three causes that move the key off the base + branch's `bd511d92…`, one of which is this lane's own executor commit. +- The 1/10 refusal diagnostic, three rounds, the third non-invasive: the cause + the three nested catch-alls discard is + `ACSCoverageAuthenticationError: CANONICAL_SIZE`, and the ceiling it belongs + to was computed from measured inputs and committed **before** the 1/15 run. +- The 1/15 run: refused as predicted, recorded with its CPU, wall, peak RSS and + the fact that no node ran. +- Found and recorded a defect in the 1/15 harness's own receipt: `sample.fraction` + and the `scope` sentence were left as the tenth harness's while the call site + ran `Fraction(1, 15)`. The harness stays as it ran; the 1/15 diagnostic + harness corrects both fields and says so. + +## Pull request + +**[PolicyEngine/microcosm#950](https://github.com/PolicyEngine/microcosm/pull/950)** +— draft, base `native-scale-transport`, `MERGEABLE`. It stays draft. + +## Done (2026-09-17, second session) + +- **The 1/15 refusal is named from the run's own raises.** The measurement + refused with the catch-all; `harness19_diag_fifteenth.py` (the 1/15 harness + plus the committed `sys.monitoring` RAISE block, diffed both ways) re-ran it + and the trace ends in `ACSCoverageAuthenticationError: CANONICAL_SIZE` from + `issue_acs_native_coverage` with exactly two `visit` frames — the same guard + and signature as 1/10. The prediction committed before the run is confirmed. +- Recorded a defect in the 1/15 harness's own receipt: `sample.fraction` and + the `scope` sentence were left as the tenth's while the call site ran + `Fraction(1, 15)`. The harness stays as it ran; the diagnostic corrects both. +- Corrected the guard's citation: `acs_native_coverage_binding.py:563-565`, + not `:562-564`, in the report and the ceiling receipt's generator. +- **Pinned five of the six refusal codes this change adds**, which had none, + and verified each of the three seal tests goes red against its own reverted + guard. `ATOMIC_OBSERVER_RETENTION` stays unpinned and both documents now say + why, including that its second conjunct is a self-comparison that cannot + fire. That is report question 7. +- **`battery_receipt.py`** rebuilds the battery's receipt from its own rows and + reproduces the committed one exactly; the design note's stale 109 comparisons + and eleven accepted pairs are corrected to 116 and fourteen. +- **The identity receipt now emits every ordered pair.** Section 7c had cited + `transport_after → us_only` for "the US half moves no key", and that row says + the opposite; `base → us_only` is the row, and it did not exist. Regenerating + at this head also re-ran the contract arm: ten of ten accepted. +- Verified, rather than assumed: both measured trees carry `packages/*/src` + byte-identical to this head; §7a's table regenerates cell for cell; §7b's + replay proof and §7d's RSS phase split match the artifacts exactly; the §2 + battery table matches the receipt row for row; and the base branch's + `bd511d92…` key is the one the brief quoted. +- Report restructured to the brief's order — tests (9), PR (10), questions (11), + caveats (12) — and five wrong cross-references repointed, including §12's + claim that the committed 1/10 trace came from a round that patches the + catch-all. It came from the round that patches nothing. + +## Done (2026-09-17, second session) — the adversarial pass + +**68 agents over six review dimensions, every finding put to two independent +verifiers whose default answer is refuted: 31 findings, 25 survived.** Five +answered in code, four in tests, sixteen in the documents, none left open. +Receipt: `experiments/native-retention-seal/adversarial-verification-receipt.json`. + +The three that mattered, each reproduced before being believed and again after +being fixed: + +- **The seal ACCEPTED a pair the comparison refuses.** An object-axis value + carrying its own `__eq__` has equal codec bytes to the plain int of the same + value and is not `==` to it. That is the dangerous direction — a run + accepting a replay the comparison refuses. +- **The seal REFUSED a pair the comparison accepts.** pandas holds `None` and + every NaN interchangeable on an object axis; the codec spelled them apart, so + a green run would have turned red. +- **A masked-integer axis folded through float64**, because `np.asarray` on a + masked integer array returns float64 with NA as NaN — lossy above `2**53`, + and the refusal code moved. + +The fold now reproduces the equivalence classes `Index.equals` actually has, +**measured** rather than read off pandas' source, and refuses `AXIS` at seal +construction for the one case a digest cannot represent. 124 new battery cases +pin all three; each half of the fix was reverted to confirm its own cases go +red. + +**And the change broke a gate that passes at the base.** +`test_us_spine_blindness.py::test_runtime_population_operators_are_source_spine_blind` +refuses a statically unresolvable subscript on a name it infers to be a column +container; every seal record is a positional tuple, so it reported 48 sites. +Verified both ways: `1 passed` at `a64f7b733`, red here. The records are now +unpacked into named fields, the one dynamic `getattr` reads through a literal +reader per comparable, and the gate passes (`1 passed in 217.42s`). Nothing +moved: no record changed shape, order or `repr`. + +**Two tests were vacuous.** An executor test's default-mode arm compared one +run's objects against another run's; the dtype census asserted the same +predicate twice and called no seal function. Both now fail against the defect +they pin. + +**Four documents described mechanisms that are not in the code** — a dtype +token, a `_comparables` digest, a `repr()` fallback and the residual risk built +on it — and the design note's own §4(1) had argued the token would be wrong. + +## Next + +1. The **quiet-machine 1/1000 re-run at the finished head** (pid 7656, launched + 2026-09-18T01:58:01Z at 79.8 GB available, head `6e3b3091c`). It re-proves + the replay at the head that ships and answers question 5's request for a + repeat without contention. `RUN-RECORD-after2.txt` states what it must + reproduce before the outcome. +2. The 21-file dependent battery, **re-run clean**. The first run had three red + files: the spine-blindness failure was real and is fixed; the completion-host + and person-status results were invalidated by my own concurrent edits to + `survey_population_replay.py` during the run, which an implementation hash + is over — the report says so rather than quoting them. +3. The final CI-shaped verification at the finished head, the PR body, and the + report's remaining open questions (now eight). + +## Inherited defect, repaired here (for the report and for Max) + +`survey_population_preparation._spill_roster` gained a `Path.read_bytes` on +`native-scale-transport` at **`b6081efcb`** ("Hash a spill segment that was +already there"). That added a `resource_accesses` entry, leaving +`graph_implementation_inventory.json`'s declared `resource_accesses_sha256` +stale, so `implementation_manifest("authenticated_survey_population_v1")` +**refused** — and `SurveyPopulationCreateKernel.implementation_hash` calls it. +**No 19-node graph run was possible at `a64f7b733`.** Bisected across +`5ff889814` → `5307249b3` (both clean) → `baaf4270c` onward (all refusing). +The transport report's §4 "No committed pin moves" was recomputed before +`b6081efcb` and is stale at its own tip. Repaired in `43fb39270`, guarded by +`test_us_implementation_inventory_contracts.py` (135 assertions; reverting the +re-pin turns both arms red, verified). + +## What moves, measured exactly + +`experiments/native-retention-seal/implementation-identity-receipt.json`: + +| comparison | roster module digests that move | +|---|---| +| `a64f7b733` → US-only commits | **none** | +| `a64f7b733` → head with the executor commit | `microcosm.graph/executor.py`, in **all ten** stages | + +`survey_population_replay.py`, `graph_atomic_survey_financial.py` and +`survey_atomic_geography.py` are in no stage roster; `executor.py` is in every +one. The re-pin above moves `inventory_sha256`, which is also in every stage +manifest. + +## Findings, proved by running code at this head + +**Neither existing seal is the seal.** The transport report's §10 question 2(b) +says "`_population_stamp` already folds everything `same_replayed_population` +compares except the *type* assertions". That sentence is wrong in **both** +directions, and both halves are proved by scripts committed under +`experiments/native-retention-seal/`: + +1. **`_population_stamp` is too strict.** + `probe_stamp_vs_comparison.py` builds a US_SCHEMA population, round-trips its + frame through `ContentStore.put_frame`/`load_frame`, and gets: + `same_replayed_population` **ACCEPTS** (the store zeroed `_data` under the + null mask, which `NONCANONICAL_NULL_BACKING`, + `survey_population_replay.py:79-82`, deliberately permits) while + `_population_stamp(expected) != _population_stamp(actual)`. So a + stamp-equality seal would **refuse a required replay**. Its own docstring + says so (`survey_atomic_geography.py:231-237`). +2. **`_frame_identity` is too weak.** `probe_frame_identity_gaps.py` finds three + discriminations `same_replayed_frame` makes that `_frame_identity` does not: + float64 NaN **payload bits** (two quiet NaNs; `NATIVE_BITS`), quiet versus + signalling NaN (`NATIVE_BITS`), and + `DataFrame.flags.allows_duplicate_labels` (`TABLE_TYPE_OR_FLAGS`). `_cell` + maps every NaN to `None`, so `_frame_identity` spells all of them `null`. + It also cannot be applied to a non-US_SCHEMA frame at all (`FRAME_TYPE`). + +**Therefore the seal is purpose-built and lives in `survey_population_replay.py`, +beside the comparison it replaces**, folding exactly the bytes each comparison +compares — no more, no less. + +**A fourth gap, from pandas rather than from this repo.** +`pd.DatetimeIndex._comparables == ['name', 'freq']`, and two DatetimeIndexes with +equal values, dtype and name but different `freq` are **not** `identical()` while +their bytes are equal. Any seal that folds only (class, dtype, name, bytes) +misses it. The seal folds `type(index)._comparables` generically. + +**Admitted dtypes are narrow**, which bounds the problem: `_series` refuses +`CategoricalDtype`, `Float64Dtype` and `DatetimeTZDtype` with +`UNSUPPORTED_EXTENSION_DTYPE`; only masked integer/boolean, `StringDtype`, +`object` and plain numpy dtypes get through. # US engine lock → policyengine-us 2.2.1 Lane: `engine-lock-pe-us-2.2.1`, off `origin/main` at `51c3143829b88382270f5af0714ae28fba14f803`, diff --git a/docs/us-native-retention-seal.md b/docs/us-native-retention-seal.md new file mode 100644 index 000000000..a1d7934dd --- /dev/null +++ b/docs/us-native-retention-seal.md @@ -0,0 +1,568 @@ +# US native build: replacing the replayed-population object comparison with a content seal + +Design authority for the change Max chose on 2026-09-17 — option (b) of the +transport lane's report §10 question 2 +(`experiments/native-scale-transport/out.md`), whose own authority is +`docs/us-native-scale-transport.md` §3d and §4. + +The problem, restated from that authority and re-derived here: the financial +runner compares its own replay against the executor's observation with +`atomic.same_replayed_population(expected[n], observed[n])` +(`graph_atomic_survey_financial.py:1796` and `:1948` **at the base**, now the +two `same_replayed_population_seals` calls at `:1882` and `:2042`), and the +replay cannot be built until `run_graph` has returned. So nineteen detached `Population` objects +must exist between observation and comparison — about 290 GiB at full source — +unless the comparison becomes a comparison of content seals. + +Every line number is at this branch's head unless it names another. Line +numbers move; re-derive the ones you rely on. In `survey_population_replay.py` +specifically, the seal's `import hashlib` shifted every line from 10 onward by +**one** against the base, so a citation into that file taken from the base +branch reads one line early. + +## 0. The report's proposed mechanism does not hold, and this is the first thing to say + +Report §10 question 2(b) says: + +> `_population_stamp` already folds everything `same_replayed_population` +> compares except the *type* assertions, which can be made on arrival without +> retaining. + +That sentence is wrong in **both** directions. Both halves are proved by +scripts committed under `experiments/native-retention-seal/`, run at this head. + +**`_population_stamp` is too strict — it would refuse a required replay.** +`probe_stamp_vs_comparison.py` builds a `US_SCHEMA` population whose +`nullable_integer` column carries `_data = [11, 71, 73]` under a mask +`[False, True, True]`, round-trips its frame through +`ContentStore.put_frame`/`load_frame` (which zeroes values beneath a null mask, +`store.py:456`), and reports: + +``` +expected masked _data: [11, 71, 73] +actual masked _data: [11, 0, 0] +same_replayed_population: ACCEPTS +_population_stamp equal : False eb6879921de1 0400e853a2dd +_frame_identity equal : True 774ed8184472 774ed8184472 +``` + +`same_replayed_population` **accepts** that pair, because +`NONCANONICAL_NULL_BACKING` (`survey_population_replay.py:80-83`) deliberately +permits the actual side's null backing to be canonically zeroed. The stamp +refuses it. `_population_stamp`'s own docstring says exactly this +(`survey_atomic_geography.py:231-237`): "Never persist it or compare it across +reconstructions: it folds physical storage parts (masked `_data` under nulls)". +A stamp-equality seal would turn every `resume="require"` replay red. + +**`_frame_identity` is too weak — it would miss real defects.** +`probe_frame_identity_gaps.py` finds three discriminations `same_replayed_frame` +makes that `_frame_identity` does not: + +``` +nan payload 0x...11 vs 0x...12 same_replayed_frame=REFUSES NATIVE_BITS +_frame_identity=same +flags allows_duplicate_labels same_replayed_frame=REFUSES +TABLE_TYPE_OR_FLAGS _frame_identity=same +quiet vs signalling NaN same_replayed_frame=REFUSES NATIVE_BITS +_frame_identity=same +``` + +`_cell` (`survey_population_preparation.py:732-745`) maps **every** NaN to +`None`, so `_frame_identity` spells all NaN payloads `null`; and nothing in it +folds `DataFrame.flags`. It is also inapplicable to a non-`US_SCHEMA` frame at +all (`FRAME_TYPE`, `:977-981`). + +**So the seal is purpose-built and lives beside the comparison it replaces**, in +`survey_population_replay.py`, folding exactly the bytes each comparison +compares — no more, no less. It reuses neither existing seal. + +## 1. Every field and assertion `same_replayed_population` compares today + +Read off `survey_population_replay.py` at this head. **Kind** is `unary` for a +predicate about one side that can be asserted on arrival, `binary` for a +comparison between the two sides that a seal must fold, and `directional` for +the one predicate that is not symmetric. + +### 1a. Population level (`:180-209`) + +| # | predicate | code | kind | +|---|---|---|---| +| P1 | `type(expected) is Population`, `type(actual) is Population` | `POPULATION_TYPE` | unary, both sides | +| P2 | `type(version) is str` (both) and `expected.version == actual.version` | `POPULATION_CONTEXT` | unary + binary | +| P3 | `tuple(sorted(owners.items()))` equal — order-**insensitive** | `POPULATION_CONTEXT` | binary | +| P4 | `all(type(v) is str for v in actual.owners.values())` | `POPULATION_CONTEXT` | unary, actual only | +| P5 | `tuple(weight_kind.items())` equal — order-**sensitive** | `POPULATION_CONTEXT` | binary | +| P6 | `all(type(v) is WeightKind for v in actual.weight_kind.values())` | `POPULATION_CONTEXT` | unary, actual only | +| P7 | `type(mass_ledger) is tuple` (both) | `POPULATION_CONTEXT` | unary | +| P8 | `all(type(r) is MassRecord ...)` over both ledgers | `POPULATION_CONTEXT` | unary | +| P9 | `canonical_json([asdict(r) for r in mass_ledger])` equal | `POPULATION_CONTEXT` | binary | +| P10 | `tuple(design_weights)` equal — key **order** | `POPULATION_CONTEXT` | binary | +| P11 | per entity `_array_bytes_equal(design_weights[e], …)`: `type is np.ndarray`, dtype equal, `not hasobject`, shape equal, `tobytes()` equal | `DESIGN_BYTES` | unary + binary | + +### 1b. Frame level (`:133-177`) + +| # | predicate | code | kind | +|---|---|---|---| +| F1 | `isinstance(expected, Frame)`, `isinstance(actual, Frame)` | `FRAME_TYPE` | unary | +| F2 | `schema` equal | `FRAME_CONTEXT` | binary | +| F3 | `entities` equal (ordered tuple) | `FRAME_CONTEXT` | binary | +| F4 | `links == () ` on **both** | `FRAME_CONTEXT` | unary | +| F5 | `canonical_json(_encode_frame_metadata(metadata))` equal | `FRAME_CONTEXT` | binary | +| F6 | `all(type(r) is MassChangeRecord ...)` over both mass logs | `FRAME_CONTEXT` | unary | +| F7 | `canonical_json([asdict(r) for r in mass_log])` equal | `FRAME_CONTEXT` | binary | +| F8 | `weighted_entities` equal | `FRAME_CONTEXT` | binary | +| F9 | `type(table) is pd.DataFrame` (both) | `TABLE_TYPE_OR_FLAGS` | unary | +| F10 | `left.flags == right.flags` | `TABLE_TYPE_OR_FLAGS` | binary | +| F11 | strata name: `_name_bytes` equal | `STRATA_NAME` | binary | +| F12 | per weighted entity `left.kind is right.kind` | `WEIGHT_BYTES` | binary | +| F13 | per weighted entity `_array_bytes_equal(values)` | `WEIGHT_BYTES` | unary + binary | + +### 1c. Axis (`:122-130`), applied to every table index, every table columns +axis, and the strata index + +| # | predicate | code | kind | +|---|---|---|---| +| A1 | `type(expected) is type(actual)` | `AXIS` | binary | +| A2 | `expected.identical(actual)` — pandas: `equals()` **and** every name in `type(index)._comparables` **and** exact class **and** dtype | `AXIS` | binary | +| A3 | `not isinstance(expected, pd.MultiIndex)` | `AXIS` | unary (expected; A1 carries it to actual) | +| A4 | `_name_bytes(name)` equal — `canonical_json(_axis_name_payload(name))` | `AXIS_NAME` | binary, plus unary encodability (`UNSUPPORTED_AXIS_NAME`) | +| A5 | `_series` over the axis array | the S codes | | + +### 1d. Series (`:49-112`), applied to every table column, every axis array and the strata + +| # | predicate | code | kind | +|---|---|---|---| +| S1 | `type(x) is pd.Series` (both) | `SERIES_DTYPE_OR_LENGTH` | unary | +| S2 | `type(expected.dtype) is type(actual.dtype)` | `SERIES_DTYPE_OR_LENGTH` | binary | +| S3 | `expected.dtype == actual.dtype` | `SERIES_DTYPE_OR_LENGTH` | binary | +| S4 | `len(expected) == len(actual)` | `SERIES_DTYPE_OR_LENGTH` | binary | +| **masked branch** — `BooleanDtype`, or `ExtensionDtype` and integer | | | | +| S5 | `_array_bytes_equal(lm, rm)` — the null masks | `MASKED_STORAGE` | binary | +| S6 | `lm.dtype is bool`; `lm.shape == (n,)`; `type(ld) is type(rd) is np.ndarray`; `not ld.dtype.hasobject`; `ld.shape == rd.shape == lm.shape` | `MASKED_STORAGE` | unary + shape | +| S7 | `ld.dtype == rd.dtype` | `MASKED_STORAGE` | binary | +| S8 | `_array_bytes_equal(ld[~lm], rd[~rm])` — the **present** values | `PRESENT_BITS` | binary | +| S9 | `_array_bytes_equal(ld, rd) or bool(np.all(rd[rm] == 0))` | `NONCANONICAL_NULL_BACKING` | **directional** | +| **string branch** — `StringDtype` | | | | +| S10 | `storage` equal and `(na_value is pd.NA)` parity | `STRING_POLICY` | binary | +| S11 | `_array_bytes_equal(isna(l), isna(r))` | `STRING_MASK` | binary | +| S12 | present cells: `type(a) is str and type(b) is str and a == b` | `STRING_VALUE` | unary + binary | +| **object branch** — `is_object_dtype` | | | | +| S13 | per cell `_encode_object_scalar(a) == _encode_object_scalar(b)` | `OBJECT_VALUE` | binary, plus unary encodability (`UNSUPPORTED_OBJECT`) | +| **native branch** | | | | +| S14 | `not isinstance(dtype, pd.api.extensions.ExtensionDtype)` | `UNSUPPORTED_EXTENSION_DTYPE` | unary | +| S15 | `_array_bytes_equal(to_numpy(l), to_numpy(r))` — type, dtype, `not hasobject`, shape, bytes | `NATIVE_BITS` | unary + binary | + +Forty-four rows, under the **twenty-two** refusal codes +`survey_population_replay.py` raises (counted off the module, not off this +table). The admitted dtype set is narrow, which bounds the problem: `_series` +refuses `CategoricalDtype`, `Float64Dtype` and `DatetimeTZDtype` with +`UNSUPPORTED_EXTENSION_DTYPE` (measured), so only masked integer/boolean, +`StringDtype`, `object` and plain numpy dtypes get through. + +The forty-four rows are a reading of the code, not a census of every mutation +that can reach it: §5's battery drives **564** comparisons, over twenty of the +twenty-two codes plus **42** pairs both paths accept, and two codes are +unreachable (`FRAME_TYPE`, because `Population` validates its own frame; +`STRING_POLICY`, because `StringDtype.__eq__` already compares storage and +`na_value`, so `SERIES_DTYPE_OR_LENGTH` fires first). Those figures are the +committed receipt's own +(`experiments/native-retention-seal/battery-receipt.json`: `comparisons`, +`agreements`, `by_verdict`), not a count taken by hand; they were 116 and +fourteen before the fix pass that closed three divergences in the object-axis +fold, whose new cases mostly drive the agreement driver too. + +## 2. Which of them `_population_stamp` already folds + +`_population_stamp` (`survey_atomic_geography.py:230-268`) folds, in order: +`canonical_json({"frame": _frame_identity(frame), "version", sorted owners, +weight_kind items, mass_ledger asdict})`; then, for every entity column in +order and then the strata, a length-prefixed `_storage_parts(series, +slice(None))` pair (physical values, null bitmap); then, per design-weight +entity, `canonical_json((entity, str(dtype), shape))` and `values.tobytes()`. + +| group | folded? | note | +|---|---|---| +| P2 version, P3 owners, P5 weight_kind, P9 mass ledger | yes | in the header `canonical_json` | +| P10 design key order, P11 design bytes | yes | the design loop | +| F2 schema, F3 entities, F8 weighted entities | yes | through `_frame_identity` / `encode_us_frame_context` | +| F5 metadata, F7 mass log | yes, but through `_normative_metadata` and `_json_data`, not `_encode_frame_metadata` | a **different** normalisation from the one the comparison uses | +| F12/F13 weights | yes | `_frame_identity` folds kind, dtype, shape and `tobytes()` | +| S5/S8 masks and present values | yes | `_storage_parts` | +| S15 native bytes | yes | `_storage_parts` | +| A4 axis names | partly | `_frame_identity` folds index `names` and the strata name; not through `_axis_name_payload` | +| **S9 directional null backing** | **folded the wrong way** | it folds the masked `_data`, so it **refuses** what the comparison accepts — §0 | +| **F10 `DataFrame.flags`** | **no** | nothing folds it | +| **A1/A2 exact index class and `_comparables`** | partly | `type(index).__name__` only; not the qualified class, not `freq` | +| all unary type assertions (P1, P4, P6, P7, P8, F1, F4, F6, F9, S1, S6, S12, S14) | no | they are assertions, not content | + +So the honest summary is: `_population_stamp` folds most of the *content*, gets +the one directional predicate backwards, misses `DataFrame.flags` outright, and +— unavoidably — folds none of the unary assertions. + +## 3. Which it does not, and how each is preserved + +Three mechanisms, applied in this order. + +**(a) Every unary assertion is made on arrival, in the seal constructor, with +the same refusal code.** `replayed_population_seal(population)` runs P1, P4, +P6, P7, P8, F1, F4, F6, F9, S1, S6, S12, S14, A3 and the two encodability +assertions (`UNSUPPORTED_OBJECT`, `UNSUPPORTED_AXIS_NAME`) against the one +population it is given, raising the identical +`SURVEY_POPULATION_REPLAY_` string. Four of them (P4, P6, and the +`actual`-side halves of the rest) are written today as assertions about +`actual` only; sealing both sides makes them fire on `expected` too. That is +strictly more closed, it fires earlier, and no code changes. + +Two are re-expressed rather than dropped, because they are not properties of +one side: + +> **Corrected 2026-09-18.** The two bullets below described a *dtype token* of +> strings and booleans, and a `_comparables` digest with a `repr()` fallback. +> **Neither is in the code**, and an adversarial pass over this note caught it: +> §4(1) of this same note argues that a spelling-based token would *miss* a +> defect the code catches, so the two sections contradicted each other and this +> was the wrong one. What the code does is the opposite of tokenising — it +> **retains the small objects** and applies the identical operator. The bullets +> now say that. + +* **S2/S3, the dtype pair.** `_series_seal` retains + `head = (type(dtype), dtype, length)` — the dtype **class object** and the + dtype **object itself**, not a spelling of either — and `_same_series_seal` + compares them as `expected_class is actual_class and expected_dtype == + actual_dtype`, which is `type(a.dtype) is type(b.dtype) and a.dtype == + b.dtype` with the operands retained rather than re-derived. Retaining the + objects is what makes the exact cases work, and §4(1) has the sharpest one: + `np.longlong` against `np.int64` has equal `str()`, equal `dtype.str` and + equal bytes, and a different dtype **class**. A token keyed on spellings + would accept that pair; this refuses it `SERIES_DTYPE_OR_LENGTH`. + `CategoricalDtype`, whose `__eq__` is not an equivalence relation, never + reaches here because S14 refuses it. + `test_the_dtype_head_is_faithful_to_the_predicate_it_replaces` sweeps every + ordered pair of the admitted dtype census through `_series` **and** through + the seal and requires the same verdict with the same code. Its earlier + version asserted `type(a) is type(b) and a == b` against + `(type(a), a) == (type(b), b)` — the same predicate written twice, calling no + seal function — which an adversarial pass caught; replacing the retained head + with `str(dtype)` now turns it red. +* **A1/A2, `type(...)` and `Index.identical`.** `_axis_seal` retains the + **class object** `type(index)`, the `_comparables` names, the raw comparable + **values**, the dtype object, the value fold and the name seal. + `_same_axis_seal` compares the class with `is`, the names with `==`, and each + comparable value with `bool(one == other)` element-wise — which is exactly + what `Index.identical` applies, and deliberately not a tuple comparison, + which would short-circuit on identity and accept a comparable whose own + `__eq__` refuses itself (pinned by + `test_a_comparable_whose_equality_refuses_itself_still_refuses`). Folding the + `_comparables` **tuple itself** closes a gap neither existing seal has: + `pd.DatetimeIndex._comparables == ['name', 'freq']` (measured at pandas + 3.0.3), so two `DatetimeIndex`es with identical values, dtype and name but + different `freq` are **not** `identical()` while their bytes are equal, and + an index class that declares a comparable this module has never seen refuses + `AXIS` rather than folding `None` for it. + +**(b) Every binary comparison folds exactly the bytes that comparison +compares.** Not an approximation of them, and not a different normalisation: +F5 folds `canonical_json(_encode_frame_metadata(metadata))` because that is +what `same_replayed_frame` compares — *not* `encode_us_frame_context`'s +`_normative_metadata`, which is what `_frame_identity` folds. S15 folds +`to_numpy(copy=False).tobytes()` with its dtype and shape, so NaN payload bits +and `-0.0` survive, which `_cell`'s `None` mapping destroys. F10 folds +`allows_duplicate_labels` — generically, over `type(flags)._keys` (measured: +`{'allows_duplicate_labels'}`), so a pandas release that adds a flag is folded +without an edit here. + +**(c) The one directional predicate, S9, is folded as three values rather than +one digest**, which is what makes an exact reproduction possible at all. Per +series the masked branch records + +* `mask_digest` — the null mask bytes (S5), +* `present_digest` — the present values' bytes with dtype and shape (S7, S8), +* `full_digest` — the whole `_data` buffer's bytes, +* `null_backing_canonical` — `bool(np.all(data[mask] == 0))` for **this** side, + +and the seal comparison requires +`present_digest` equal **and** +(`actual.null_backing_canonical` **or** `full_digest` equal), +which is `_array_bytes_equal(ld, rd) or np.all(rd[rm] == 0)` term for term, per +series, with the same direction and the same `NONCANONICAL_NULL_BACKING` code. +A single population-wide flag would **not** reproduce it: today's disjunction is +evaluated per column, and one non-canonical column must not force whole-frame +byte equality on the others. + +The seal record is therefore a nested structure of 32-byte digests and small +tokens whose size is **O(columns), not O(rows)** — for a US frame of six +entities and a few hundred columns, tens of kilobytes per node against about +1.5 GiB for the retained population at 1/10. + +## 4. What is no longer proved + +**Nothing about the content.** Every one of the forty-four discriminations in +§1 still refuses the same defect with the same code; §5's battery is the proof +obligation and it is discharged mutation by mutation, in both directions. + +Three things change in character rather than in coverage, and this note states +them rather than leaving them to be found. All three were established by +adversarial passes over the finished seal, not by writing it. + +> **Corrected 2026-09-18.** There was a fourth item here, and it was the one +> place this note said something false about what a run proves. It claimed that +> on an object-dtype axis the fold of the store codec's bytes "is never weaker +> than `equals` and is stricter on exactly those pairs", and that "every defect +> is still refused". A second adversarial pass ran both paths and found the +> fold **weaker** in one case and **stricter** in another it had not named, so +> for a period this change did *narrow* what a run proves. The fold was +> rewritten to reproduce the equivalence classes `Index.equals` actually has, +> the object-axis code no longer moves, and the withdrawn item is set out below +> the list rather than deleted. + +1. **Byte equality becomes sha256 equality.** Today `same_replayed_population` + compares the bytes; the seal compares a 256-bit digest of those bytes. This + is the same substitution the whole runtime already rests on — + `_population_stamp`, `_frame_identity`, `preparation_sha256`, every node key + and every store address are sha256 digests of content — so it introduces no + assumption the build does not already make. It is not nothing, and it is + written here so the owner can see it. Every predicate that is **not** a byte + comparison keeps the object it applies to and the identical `is`/`==`: the + dtype, its class, the index class, the axis name, the `WeightKind`, the + flags. That is why `np.longlong` against `np.int64` — equal dtypes, equal + `str()`, equal `dtype.str`, equal bytes, different dtype class — still + refuses `SERIES_DTYPE_OR_LENGTH`, which a token built from spellings would + have missed. +2. **Unary assertions fire earlier.** A `MultiIndex`, an unencodable object + cell, a `Float64` column or a non-`str` owner value is refused when the + population is observed rather than when it is compared, with the same code. + For `expected`-side defects that is unchanged in timing; for `actual`-side + defects the refusal moves from after `run_graph` returns to inside the + observer callback, which `run_graph` documents as refusing the run + (`executor.py:2453-2454`). +3. **A one-sided defect now fires before a two-sided difference.** When a + population carries both — an unsupported dtype *and* a changed version, say + — today's comparison reports whichever its own order reaches first, and the + seal reports the one-sided one, because the seal is built before anything is + compared. The same set of codes; a different precedence between them. No + pair in the battery carries two defects at once, and none is manufactured. +Every non-object axis kind is exact, including the three `array_equivalent` is +byte-tolerant for: `float`, `complex` and `bool` all collapse NaN payloads, NaN +sign, signed zeros and bool bytes outside `{0, 1}` before folding, so a +byte-only difference still reaches `NATIVE_BITS`. Since the second adversarial +pass, a **masked-integer** axis is exact too: `np.asarray` on a masked integer +array returns float64 with NA as NaN, so an `Int64` axis's fold was a float +fold and lost every distinction above `2**53`; it now takes the array's exact +object view. + +### 4a. The withdrawn fourth item, and why it is left here + +It said that on an object-dtype axis a difference reports `AXIS` rather than +`OBJECT_VALUE`, because `Index.equals` there is an element-wise `==` over +arbitrary Python objects that no digest reproduces, and that the fold of the +store codec's bytes is therefore "never weaker than `equals` and stricter on +exactly those pairs" — `True` against `1`, `-0.0` against `0.0`. + +**Both halves were false**, and each was reproduced by running the two paths: + +* **Weaker.** Two values with equal codec bytes need not be `==`, when one + carries its own `__eq__`. The comparison refused `AXIS`; the seal + **accepted**. That is a run accepting a replay the comparison refuses, and + for as long as it stood, this change did narrow what a run proves. +* **Stricter, in an unnamed case.** pandas holds `None` and every NaN + interchangeable on an object axis and the codec spells them apart, so the + comparison **accepted** and the seal refused — a green run turning red. + +The fold is now `_object_axis_equivalence`, which reproduces the equivalence +classes `Index.equals` actually has, **measured on this pandas pin** rather +than read off its source: `{None, NaN}` is one class, `pd.NA` and `pd.NaT` are +each their own, bool/int/float share one numeric class by exact value, and +`str` and `bytes` are each their own. The one thing no digest can represent — +a value's own `__eq__` — refuses `AXIS` when the seal is built, on either +operand. The byte-exact discriminations the codec makes and `==` does not are +not lost: they reach `OBJECT_VALUE` through the arm `_axis` itself falls +through to, which is what the comparison reports, so **the object-axis code no +longer moves at all.** + +So the honest answer to "what is no longer proved" is: nothing, now — and it +was not nothing between the first version of this note and the fix. That is +why the item is withdrawn in place rather than deleted. The report §10's +*stated mechanism* was wrong and §0 of this note says so and replaces it; the +*decision* — compare content seals, not objects — is implemented as chosen. + +## 5. The proof obligation + +For every row of §1, a test that mutates exactly that property in one of two +otherwise-equal populations and asserts: + +* `same_replayed_population` refuses, with its code — this half already exists + for most rows in `packages/microcosm-build/tests/test_us_survey_population_replay.py` + and is extended to cover the rest; +* the **seal** comparison refuses the same mutation with the same code. + +Plus, in both directions, the pairs today's comparison **accepts** — the store +round trip of §0, the object-scalar equivalences of +`test_object_scalar_equivalence_uses_actual_store_types` — which the seal must +also accept. A mutation the seal misses is a finding, not a test to delete. + +**And a seeded sweep beside the hand-built battery, because the battery tests +the cases its author thought of.** Two of the three divergences §4a records +lived behind a battery of 116 agreeing comparisons and a claim that every +defect is still refused. `experiments/native-retention-seal/agreement_fuzz.py` +walks a deterministic pseudo-random sweep over seven axis kinds, a 21-value +object pool and nine column mutations, driving every pair through both paths: +3,852 pairs, nine refusal codes, 466 mutual acceptances, **0 disagreements**. +It would have found two of the three. Any change that replaces a predicate with +a fold should carry one. + +## 6. Fail-closed after the change + +**Every refusal code that exists today still fires on the same defect.** All +twenty-two are raised by the seal constructor (one-sided) or the seal +comparison (two-sided), with the same `SURVEY_POPULATION_REPLAY_` prefix and +the same suffix. **None is retired**, and §5's receipt records which comparison +reached which. + +Six codes are **added**, none of them about a population's content, and this +note lists them rather than saying "none" and being wrong: + +| code | guards | +|---|---| +| `SURVEY_POPULATION_REPLAY_FRAME_SEAL_PROTOCOL` | a seal record that is not a frame seal of this protocol version | +| `SURVEY_POPULATION_REPLAY_POPULATION_SEAL_PROTOCOL` | the same for a population seal | +| `SURVEY_POPULATION_REPLAY_SEAL_TYPE` | `seal_identity` handed something that is not a seal record | +| `ATOMIC_OBSERVER_RETENTION` | the observed roster is not exactly the declared consumers, or an arrival seal's identity has moved | +| `FINANCIAL_SEALED_NODE_SCOPE` | a sealed node reaching the completion-boundary or manifest stamp arms, which the retention flag makes unreachable | +| `RETAIN_EVERY_NODE_POPULATION_FLAG` | the private retention flag is not a bool, or is set together with `child_property` | + +**Five of those six are pinned; the sixth is not, and this note says which.** +The three seal codes are pinned in +`test_us_survey_population_replay.py` — `test_a_foreign_frame_seal_record_refuses_frame_seal_protocol`, +`test_a_foreign_population_seal_record_refuses_population_seal_protocol` and +`test_seal_identity_refuses_anything_that_is_not_a_seal_record`, each verified +to go red when its own guard is reverted — and `RETAIN_EVERY_NODE_POPULATION_FLAG` +and `FINANCIAL_SEALED_NODE_SCOPE` in `test_us_graph_atomic_survey_financial.py`. +`ATOMIC_OBSERVER_RETENTION` has no test: its first conjunct +(`set(observed) == declared_consumers`) is reachable only from inside a real +nineteen-node run with an observer made to retain the wrong roster, and its +second conjunct re-derives `seal_identity` from the very record whose identity +it compares against, so it cannot fail while a seal record's `repr` is stable. +That asymmetry is stated rather than smoothed over, and it is a question for +the owner rather than a silent gap. +**`FINANCIAL_NODE_POPULATION_CHANGED` after the change** means: *for a node +whose `Population` object the run still retains — the declared-consumer roster — +the object's in-process `_population_stamp` differs from the one recorded when +the run was issued; and for every other node, the seal record the run retains +is not the one recorded at issuance.* Both arms refuse the same class of defect +the one arm refuses today — something the run retained about a node's +population changed after issuance — and neither arm is vacuous, because the +seal record is re-digested rather than merely re-read. + +**The declared-consumer roster.** `result.financial_population is +observed[final_node]` (`graph_atomic_survey_financial.py:1897` at the base, +`:1986` here) is an identity check, so the objects a caller holds must be the +objects the observer saw. The base financial run declares three: the final node (`financial.ATTACH_NODE`, or +`_tax_module().GATE_NODE` when the tax rebase is enabled), +`financial.ATTACH_NODE` itself (`legacy_population`, `:1821` at the base), and the property +population (`observed[final_node]` before the rebase moves `final_node`, +`:1818` at the base). Those three are retained as objects and stamped exactly as today. +Every other observation is sealed on arrival and dropped. + +**The completion host is a consumer of the base run's whole roster, and this +note says so because reading the code was not enough to find it — a test was.** +`graph_survey_completion_host` runs its own `run_graph` with its own observer +(`:781-794`), retains every observation, and pins their object ids in its own +identity fence (`:543-545`, `:572`). Those parts do not move. But at `:814-816` +it reads the **base** run's `state.node_populations` as its own expected +populations for the base-graph nodes, compares them against its own +observations, and hands them to `atomic._states`, which reads +`population.frame.table(entity)` for every structural node +(`graph_atomic_survey_population.py:85-96`). Seals cannot serve that. + +So the base run takes a private flag, `_retain_every_node_population`, whose +only caller is `run_atomic_survey_financial`'s own recursive base call when +`child_property is not None` (`:1356-1371`). With it set, the declared-consumer +roster is every node and the run retains exactly what it retains today. The +flag and `child_property` are mutually exclusive, which the runner requires. +`_node_population_seals` accepts both shapes. + +This is the one place where the memory saving does not apply, and it is the +completion path rather than the base 19-node path the measured wall belongs +to. Removing it means giving the completion host the same seal treatment and +finding a frame-free form for `_states`; that is a second change with its own +argument. + +**The residual risks this note will not hide.** An earlier version of this +paragraph declared one that **does not exist**: a `repr()` fallback in the +`_comparables` fold. There is no such fallback — `_axis_seal` retains the raw +comparable values and `_same_axis_seal` compares each with the same `==` +`Index.identical` applies, so the comparables arm introduces no divergence in +either direction. The three that are real, each reproduced before being written +down: + +1. **`seal_identity` depends on `repr`.** It is `sha256(repr(seal))`, and a + seal retains live dtype, class and `WeightKind` objects whose canonical JSON + does not exist. That is the *stamp*, not the comparison: two seals are + compared field by field by `same_replayed_population_seals`, and `repr` only + decides the digest a run retains per node for + `FINANCIAL_NODE_POPULATION_CHANGED`. Two objects that are `==`, of the same + class, with different `repr` would give different stamps — but the stamp is + only ever compared with another taken in the same process, from the same + object, which its own docstring says. +2. **An object-dtype axis cannot be folded exactly by any digest**, because + `Index.equals` there is an element-wise `==` over arbitrary Python objects. + `_object_axis_equivalence` reproduces the equivalence classes that operator + actually has — measured, not assumed — and refuses `AXIS` at seal + construction for a value that is not `==` to the plain builtin the codec + encodes it as, which is the only case a digest cannot represent. Before that + guard the seal **accepted** a pair the comparison refuses; §4 records it. +3. **A one-sided refusal now takes precedence** over a two-sided difference on + the same operand, because the one-sided assertions fire when the seal is + built. Both refuse; the code between them can differ. The clearest instance + is an object axis carrying a `datetime64` leaf and a value difference: the + comparison reports `AXIS`, the seal `UNSUPPORTED_OBJECT`. + +No index class in this runtime reaches the exotic comparables case at all: US +frames carry `Index` and `RangeIndex`, whose `_comparables` is `['name']` +(measured), and `graph_context.encode_us_frame_context` requires group entities +to carry a default unnamed `RangeIndex` (`:130-143`). + +## 7. The `microcosm-graph` half + +`_observer_snapshot` (`executor.py:356-408`) detaches by round-tripping every +entity and link table plus the strata through `pickle.loads(pickle.dumps(..., +protocol=5))` — one full independent copy per reached node, cache hits included +(the round trip is `executor.py:373`, inside `_observer_snapshot` at +`:356`; the call that takes one per reached node is `:2787-2791`, which at +the base was the single line `:2774`). An observer that only seals never retains and never mutates, so +it needs no detached copy. + +`run_graph` gains `_population_observer_detach: bool = True`, private and +paired with `_population_observer`. When it is `False` the observer receives the +live admitted population and no snapshot is allocated. Default behaviour is +unchanged, the keyword enters no key, no receipt and no cache record, and the +change imports nothing from the US runtime. + +**It is deliberately not called `population_retention`.** That keyword existed +on PR #893's original branch (commit `6c0f24c77`, layer 08) and was dropped; it +made the **manifest's attached population views** lazy against the content +store, which is a different target from the observer's per-node detached +snapshots (`docs/us-native-scale-transport.md` §4). Reusing the name for this +would invite exactly the confusion that document warns about. + +Invariants that do not move, each with the test that pins it +(`packages/microcosm-graph/tests/test_graph_executor.py`): + +| invariant | test | +|---|---| +| exactly once per reached node, in `compiled.order`, cold and on hits | `:4130-4166` | +| an observer's exception refuses the run with the observer's type | `:4172-4179` | +| a mutating, retaining observer cannot move a key, a manifest or a store object — **in the default detaching mode** | `:4183-4248` | +| with no observer, no snapshot is allocated | `:4368-4374` | + +The new tests are the shape of the last: with an observer **and** +`_population_observer_detach=False`, a monkeypatched `_observer_snapshot` that +raises must never be called; the run's manifest key and every store object must +equal a no-observer run's; and the observer must receive the same object the +executor holds, which is the mode's whole point and is what the caller is +declaring it will not mutate. + +That declaration is the mode's one honest cost: in this mode the executor no +longer *enforces* that the observer cannot reach execution state, it *trusts* +the caller's declaration. The default mode still enforces it, and this mode is +opt-in and private. diff --git a/experiments/native-retention-seal/RUN-RECORD-after.txt b/experiments/native-retention-seal/RUN-RECORD-after.txt new file mode 100644 index 000000000..4291cc09e --- /dev/null +++ b/experiments/native-retention-seal/RUN-RECORD-after.txt @@ -0,0 +1,24 @@ +native-retention-seal lane — 1/1000 after-run record +launched: 2026-09-17T23:40:26Z (gate opened at 23:40:26Z, available 80.7 GB > 40 GB) +pid: 82878 +pgid: 82878 (session leader; os.setsid() in setsid_exec.py, pid kept across the exec) +command: /Users/maxghenis/PolicyEngine/_worktrees/microcosm-native-v5/.venv/bin/python -I -B -S \ + /Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-after/.measure/harness19_after_with_required_replay.py +harness: a byte-identical copy of the native-scale lane's committed + experiments/native-scale-transport/harness19_after_with_required_replay.py + (sha256 b020bec601b9aea7f99eb9675e7cbd879d48a7fad850e974aa2b9f34beb7d5da), + copied rather than edited, as the brief requires +env: MEASURE_BASE=/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-after + (throwaway worktree, detached at ad77fe3874d2cc5127bad7caf2f6a9cb05ed3ccb) + MEASURE_RUN=/Users/maxghenis/PolicyEngine/_recovered/pilot-runs/native45-v5/run (read-only) + MEASURE_PROBE=.../microcosm-retention-after/.measure/after + MEASURE_LABEL=native-retention-seal-after-1-1000 +ceilings: RLIMIT_CPU hard 9060 s (setsid_exec), harness soft 9000 CPU-s, + 12000 wall-s, 48 GiB RSS +phases: cold 19-node run at 1/1000, seed 20260908, then the same graph with + resume="require" against the store the cold run just wrote +machine at launch: the native-scale lane's own 1/10 run had already stopped + (see the report); the lane's completion-host pytest was running + concurrently on another core, which affects wall clock and not the + process_time CPU figures the report leads with +kill, if ever needed: kill 82878 -- exact pid only, never a pattern kill diff --git a/experiments/native-retention-seal/RUN-RECORD-after2.txt b/experiments/native-retention-seal/RUN-RECORD-after2.txt new file mode 100644 index 000000000..8ad0aa1f2 --- /dev/null +++ b/experiments/native-retention-seal/RUN-RECORD-after2.txt @@ -0,0 +1,65 @@ +native-retention-seal lane — the 1/1000 after-run, repeated at the finished head + on a quiet machine + +why this run exists, both reasons: + 1. The first after-run (RUN-RECORD-after.txt, pid 82878) measured + ad77fe3874d2cc5127bad7caf2f6a9cb05ed3ccb. After it, an adversarial + verification pass found three divergences in the seal's object-axis value + fold and one gate this change broke, and the fixes changed + survey_population_replay.py. The brief asks for the cold run and its + required replay at the implemented head, so the measured head has to be + the head that ships. + 2. Report section 7d could not attribute a +6 GB rise in the replay phase's + peak RSS, and named the one candidate it could not test: the first run had + 67-80 GB free throughout where the base branch's runs shared a machine + holding 43-62 GB, and pages are returned under pressure and retained + without it. Question 5 asked whether to repeat it on a quiet machine. This + run is that repeat, launched with nothing else of this lane's running. + +first attempt: pid 4351, launched 2026-09-18T01:53:40Z at 79.7 GB available, + stopped by `kill 4351` about 8 minutes in, before it had written any + result, because four more findings were still to be answered and one of + them changed packages/microcosm-graph/src/.../executor.py. A run whose + measured head is not the head that ships is not the run the brief asks + for, so it was restarted rather than reported. +launched: 2026-09-18T01:58:01Z (gate opened at 79.8 GB available > 40 GB) +pid: 7656 +pgid: 7656 (session leader; os.setsid() in setsid_exec.py, pid kept across exec) +head: 6e3b3091c2a11de0d4d1a84578e1ae3f3d50d8a1 -- the finished head, with the + seal fixes, the unpacked seal records and the four later answers. + `git diff 6e3b3091c HEAD -- 'packages/*/src'` is empty at the time this + record is written, and no further source edit is made while it runs. + The measurement worktree is a separate checkout, so commits in the lane + worktree cannot reach the tree being measured. +tree: /Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-after2 + a fresh throwaway detached worktree, created for this run +harness: a byte-identical copy of the base branch's committed + experiments/native-scale-transport/harness19_after_with_required_replay.py + (sha256 b020bec601b9aea7f99eb9675e7cbd879d48a7fad850e974aa2b9f34beb7d5da, + verified after copying), copied rather than edited +launcher: experiments/native-retention-seal/launch_after.sh, unchanged -- it + takes the tree, the head and the label from the environment, so the same + committed launcher drives both after-runs +env: MEASURE_RUN=/Users/maxghenis/PolicyEngine/_recovered/pilot-runs/native45-v5/run + (read-only, the same staged pilot sources the first after-run read) + MEASURE_LABEL=native-retention-seal-after2-1-1000-quiet +ceilings: RLIMIT_CPU hard 9060 s (setsid_exec), harness soft 9000 CPU-s, + 12000 wall-s, 48 GiB RSS -- the first after-run's, unchanged, and + none lowered +machine at launch: nothing else of this lane's was running. The 21-file + dependent battery is deliberately held until this run exits, because + this run's whole second purpose is a reading taken without contention. +kill, if ever needed: kill 4351 -- exact pid only, never a pattern kill + +what this run must reproduce, for the change to be sound: + - status COMPLETED_NINETEEN_NODE_AND_REQUIRED_REPLAY + - manifest key identical between the cold run and the replay + - store bytes identical: 0 paths added, 0 changed + - the same manifest key as the first after-run, a08d5536bcc93e0e065e5756 + a8453c78c526673b998274523906fd77546c015f, because the only source file + that changed between the two heads is survey_population_replay.py, which + is in no stage roster and in none of the inventory's 124 contracts. If the + key moves, that reasoning is wrong and the report says so instead. + +--- result --- +(follows when the run exits) diff --git a/experiments/native-retention-seal/RUN-RECORD-diagnostic.txt b/experiments/native-retention-seal/RUN-RECORD-diagnostic.txt new file mode 100644 index 000000000..f74dff7a3 --- /dev/null +++ b/experiments/native-retention-seal/RUN-RECORD-diagnostic.txt @@ -0,0 +1,46 @@ +native-retention-seal lane — 1/10 refusal diagnostic +launched: 2026-09-18T00:0xZ (second attempt; the first exited immediately because + setsid_exec had been given a 1,800 s RLIMIT_CPU that the harness then + tried to raise to 21,660 -- "not allowed to raise maximum limit") +pid: 65093 +pgid: 65093 (session leader) +purpose: the native-scale lane's own 1/10 run reached its 70 GB gate at + 2026-09-17T22:58:25Z, ran 573 CPU-s to 8.17 GB, and STOPPED with + SurveyPopulationPreparationError: PREPARATION_ISSUANCE_REFUSED. That + is a catch-all that discards the cause (`raise ... from None`, + survey_population_preparation.py:2084), so its artifact cannot name + what refused. Its snapshots directory holds the ACS housing capture + and no `preparation/` roster spill, so it refused before the roster + transport, inside source authentication. +tree: /Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-diagnostic + detached at this lane's head, with ONE uncommitted change: the catch-all + carries the original exception's module, type and message into the + SurveyPopulationPreparationError it raises, and chains it with `from`. + That change is diagnostic only and is never committed to this branch. +sources: /Users/maxghenis/PolicyEngine/_worktrees/native-scale-runs/run-tenth + (the native-scale lane's own 1/10 clone; read only, never written) +harness: experiments/native-scale-transport/harness19_tenth.py, copied unedited +ceilings: RLIMIT_CPU hard 21660 s, harness soft 21600 CPU-s, 43200 wall-s, 64 GiB +kill, if ever needed: kill 65093 -- exact pid only, never a pattern kill + +--- round 1 (pid 65093), result --- +STOPPED_SurveyPopulationPreparationError: PREPARATION_ISSUANCE_REFUSED: + microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError: + NATIVE_ISSUANCE_REFUSED +i.e. the cause is itself a catch-all. There are three nested ones on this path, +each `raise ... from None`. + +--- round 2 (pid 54592), refused before it started, and the refusal is the finding --- +Patching the other catch-alls (acs_native_coverage_binding, +acs_person_coverage_authentication, acs_population_catalogue) refused in 3 CPU-s +with ACSNativeCoverageBindingError: UNREVIEWED_PREPARATION, because +`acs_native_coverage_binding._producer()` pins the sha256 of four named ACS +module files (`_ACCEPTED`, `:232-237`). Those modules cannot be instrumented at +all. The patches were reverted. + +--- round 3 (pid 64817), non-invasive --- +harness19_diag.py is harness19_tenth.py plus one block that installs a +`sys.monitoring` RAISE callback and writes every non-routine raise it sees to +`raises.json` at exit. It changes no byte of the measured tree, so no source +pin moves and no producer refuses. It is a diagnostic harness, not a source +change, and it is committed alongside the record so the result is reproducible. diff --git a/experiments/native-retention-seal/RUN-RECORD-fifteenth.txt b/experiments/native-retention-seal/RUN-RECORD-fifteenth.txt new file mode 100644 index 000000000..8159472a1 --- /dev/null +++ b/experiments/native-retention-seal/RUN-RECORD-fifteenth.txt @@ -0,0 +1,106 @@ +native-retention-seal lane — 1/15 run record +queued: 2026-09-17T23:55Z +waiter pid: 45669 (zsh ./launch_fifteenth.sh) +gates: waits for this lane's own 1/1000 after-run (pid 82878) to exit, so that + neither measurement's wall clock or peak RSS is the other's contention, + then for available memory > 45 GB, polling every 60 s, refusing after 6 h +source tree: /Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth + detached at 0bc16009925551abce06bf31d6bedd891366e8ca + (packages/ byte-identical to the 1/1000 tree, verified by diff -r) +sources: /Users/maxghenis/PolicyEngine/_worktrees/native-scale-runs/run-fifteenth + selection-request.json carries fraction [1,15]; every other file is an + APFS clonefile copy of the staged pilot original with a matching + sha256 and its own inode. `cp -c` was proved not to change the + source's link count (the staged inputs carry a pre-existing second + link, uniformly, from elsewhere in the recovered tree). +harness: harness19_fifteenth.py -- the native-scale lane's committed + harness19_tenth.py with exactly three changes: fraction 1/15, the + retention brief's 48 GiB RSS ceiling, and the label. Verified by + diffing the two bodies. +ceilings: RLIMIT_CPU hard 21660 s (setsid_exec), harness soft 21600 CPU-s, + 43200 wall-s, 48 GiB RSS +the harness pid appears in fifteenth/launch.log (and in fifteenth-launch.log) +once the gates open; record it there +kill, if ever needed: kill -- exact pid only, never a pattern kill +note: the native-scale lane's own 1/10 run reached its gate at 22:58:25Z on + 2026-09-17, ran 573 CPU-s and STOPPED with + SurveyPopulationPreparationError: PREPARATION_ISSUANCE_REFUSED. That is a + catch-all that discards the cause (`raise ... from None`, + survey_population_preparation.py:2084), so the artifact does not say what + refused. This run is the next evidence on that question. + +--- started --- +2026-09-18T00:35:15Z: the 1/1000 after-run (pid 82878) exited, then the gate +opened at available 76.2 GB > 45 GB. +harness pid: 45669 / pgid 45669 (session leader; the waiter shell exec'd into +setsid_exec, which exec'd into the harness, so the pid the shell printed is the +harness's own). +kill, if ever needed: kill 45669 -- exact pid only, never a pattern kill +prediction on record BEFORE the outcome: this run refuses at +acs_native_coverage_binding.py:562-564 with CANONICAL_SIZE, because 1/15 needs +about 102,151 ACS serialnos = 1,634,409 canonical-JSON bytes against a 1 MiB +cap. See acs-serialno-ceiling-receipt.json, computed and committed first. + +--- result --- +2026-09-18T00:45:22Z (605.7 s after the start): STOPPED. + status SurveyPopulationPreparationError: PREPARATION_ISSUANCE_REFUSED + CPU 605.651883 s (ceiling 21,600; 2.8% of it) + wall 606.550110 s (ceiling 43,200) + peak RSS 8,279,228,416 B = 8.28 GB (ceiling 48 GiB; 16% of it) + nodes run 0 -- `node_wall_times` is the empty list + runner call entered at wall 2.028 s / cpu 1.806 s / RSS 402,259,968 B and + returned at wall 605.690 s / cpu 604.791 s, so the whole run is inside the + runner call and none of it is in a node loop. +artifact: experiments/native-retention-seal/measurement-fifteenth-refusal.json + (a copy of .measure/fifteenth/repeated-verification-measurement.json) + +The refusal is the predicted one's family, and the prediction on record above +named the code. `PREPARATION_ISSUANCE_REFUSED` is a catch-all that discards its +cause (`raise ... from None`, survey_population_preparation.py:2084), so this +artifact cannot name what refused; the 1/15 diagnostic below does. + +--- a defect in this harness's own receipt, not in the run --- +The run really did sample 1/15: `harness19_fifteenth.py:604` passes +`fraction=Fraction(1, 15)`, and the staged sources' +`sources/selection-request.json` carries `"fraction":[1,15]`. But two receipt +fields were left as the tenth harness's while the three code changes were made: + + harness19_fifteenth.py:516 "sample": {"fraction": [1, 10], "seed": 20260908} + harness19_fifteenth.py:517 "scope": "... at 1/10 -- 158,737 source households ..." + +So `measurement-fifteenth-refusal.json` reports `sample.fraction == [1, 10]` +and a scope sentence naming 1/10, and both are wrong about the run that wrote +them. The harness is committed as it ran and is not being retrofitted; the +authoritative record of the fraction is the call site and the staged selection +request, both cited above. The 1/15 diagnostic harness corrects both fields and +says so in its own docstring. + +--- the 1/15 refusal diagnostic --- +purpose: recover the cause the three nested catch-alls discard, at 1/15, the + way round 3 of the 1/10 diagnostic did. +harness: harness19_diag_fifteenth.py = harness19_fifteenth.py with the 1/10 + diagnostic's committed `sys.monitoring` RAISE block inserted at the + same point in the file, plus the two receipt-field corrections above. + Proved by diffing both ways: against harness19_fifteenth.py the only + code difference is the inserted block; against harness19_diag.py the + only differences are the docstring, `RSS_CEILING`, `sample`, `scope` + and `Fraction(1, 15)`. It changes no byte of the measured tree, so no + source pin moves and no producer refuses. +tree: the same worktree the measurement ran in, + /Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth, + detached at 0bc16009925551abce06bf31d6bedd891366e8ca, `git status` + clean; the harness lives in its gitignored `.measure/`. +sources: the same staged 1/15 clone, read only. +gates: the measurement's own, unchanged -- available > 45 GB, RLIMIT_CPU + 21,660 s, harness soft 21,600 CPU-s / 43,200 wall-s / 48 GiB RSS. +first attempt: pid 32611, launched 00:52:06Z at available 81.1 GB, stopped by + `kill 32611` at 00:53:1xZ after ~3 min, before it had written + anything, because its receipt would have inherited the two stale + fields above. Its partial probe directory was removed. +run: pid 47936 / pgid 47936 (session leader), launched 00:53:59Z at + available 79.9 GB. +kill, if ever needed: kill 47936 -- exact pid only, never a pattern kill +note: this lane's 21-file dependent pytest battery is running concurrently + on other cores. The refusal is a byte-budget comparison and cannot + turn on load; the CPU and wall figures it reports can, and nothing in + the report leads with them. diff --git a/experiments/native-retention-seal/acs-serialno-ceiling-receipt.json b/experiments/native-retention-seal/acs-serialno-ceiling-receipt.json new file mode 100644 index 000000000..2aff7fb7d --- /dev/null +++ b/experiments/native-retention-seal/acs-serialno-ceiling-receipt.json @@ -0,0 +1,70 @@ +{ + "scope": "diagnostic; not a build, certification or release artifact", + "release_eligible": false, + "cap_bytes": 1048576, + "cap_name": "acs_housing_universe_source.ACS_HU_RECEIPT_MAX_BYTES", + "guard": "acs_native_coverage_binding.py:563-565", + "serialno_widths_observed": [ + 13 + ], + "json_bytes_per_serialno": 16, + "serialnos_admitted": 65535, + "pilot_selection": { + "selected_households": 1584, + "acs": 1529, + "asec": 55, + "acs_share": 0.965278, + "supplied_households": 1587376 + }, + "binds_above_selected_households": 67892, + "binds_above_share_of_source": 0.04277, + "transport_lane_lifted_ceiling_1": { + "households": 96860, + "share_of_source": 0.061, + "note": "this bound is LOWER, so it refuses first" + }, + "by_fraction": { + "1/1000": { + "selected_households": 1587, + "acs_serialnos": 1532, + "canonical_json_bytes": 24516, + "refuses": false + }, + "1/30": { + "selected_households": 52913, + "acs_serialnos": 51075, + "canonical_json_bytes": 817205, + "refuses": false + }, + "1/24": { + "selected_households": 66141, + "acs_serialnos": 63844, + "canonical_json_bytes": 1021506, + "refuses": false + }, + "1/20": { + "selected_households": 79369, + "acs_serialnos": 76613, + "canonical_json_bytes": 1225807, + "refuses": true + }, + "1/15": { + "selected_households": 105825, + "acs_serialnos": 102151, + "canonical_json_bytes": 1634409, + "refuses": true + }, + "1/10": { + "selected_households": 158738, + "acs_serialnos": 153226, + "canonical_json_bytes": 2451614, + "refuses": true + }, + "1/1": { + "selected_households": 1587376, + "acs_serialnos": 1532259, + "canonical_json_bytes": 24516140, + "refuses": true + } + } +} diff --git a/experiments/native-retention-seal/acs_serialno_ceiling_receipt.py b/experiments/native-retention-seal/acs_serialno_ceiling_receipt.py new file mode 100644 index 000000000..8cb2d0071 --- /dev/null +++ b/experiments/native-retention-seal/acs_serialno_ceiling_receipt.py @@ -0,0 +1,127 @@ +"""The ceiling that actually binds the native path, and where it sits. + +The native-scale lane's 1/10 run reached its memory gate, ran 573 CPU-s and +stopped with ``PREPARATION_ISSUANCE_REFUSED`` -- a catch-all that discards its +cause. A ``sys.monitoring`` RAISE trace (``harness19_diag.py``, this lane) +names it: ``ACSCoverageAuthenticationError: CANONICAL_SIZE``, raised through +``acs_person_coverage_authentication._json``'s ``charge`` with exactly two +``visit`` frames beneath it -- a FLAT list, not the nested evidence receipt -- +called from ``acs_native_coverage_binding.issue_acs_native_coverage``. That is +the guard at ``acs_native_coverage_binding.py:563-565``: + + coverage._json(serialnos, min(MAX_EVIDENCE_BYTES, housing.ACS_HU_RECEIPT_MAX_BYTES)) + +``MAX_EVIDENCE_BYTES`` is 2 MiB and ``ACS_HU_RECEIPT_MAX_BYTES`` is 1 MiB, so +the bound on the selected-ACS-SERIALNO list is **1 MiB**, and +``survey_population_preparation.py:1959-1961`` always passes +``serialnos=acs_keys``, never ``None``. + +This script computes where that binds, from measured inputs only: the ACS +SERIALNO width read off the staged source, and the ACS share of a selection +read off the recovered 1/1000 pilot's own committed preparation receipt. + +Nothing here is a build, a certification or a release artifact. It reads two +local files and writes one JSON. +""" + +import csv +import io +import json +import pathlib +import sys +import zipfile + +ACS_HOUSING_ZIP = pathlib.Path( + "/Users/maxghenis/PolicyEngine/_recovered/pilot-runs/native45-v5/run" + "/sources/acs/csv_hus.zip" +) +PILOT_RECEIPT = pathlib.Path( + "/Users/maxghenis/PolicyEngine/_recovered/pilot-runs/native19-required-20260912" + "/run/financial-artifacts/preparation.json" +) +CAP = 1024**2 # acs_housing_universe_source.ACS_HU_RECEIPT_MAX_BYTES +SAMPLE_ROWS = 20_000 + + +def serialno_width(): + with zipfile.ZipFile(ACS_HOUSING_ZIP) as archive: + name = next(n for n in archive.namelist() if n.lower().endswith(".csv")) + with archive.open(name) as handle: + reader = csv.reader(io.TextIOWrapper(handle, encoding="utf-8")) + column = next(reader).index("SERIALNO") + widths = set() + for index, row in enumerate(reader): + widths.add(len(row[column])) + if index >= SAMPLE_ROWS: + break + return sorted(widths) + + +def main(): + widths = serialno_width() + receipt = json.loads(PILOT_RECEIPT.read_text()) + households = receipt["origins"]["households"] + acs = sum(1 for row in households if row["source"] == "acs") + supplied = receipt["selection"]["supplied_households"] + # ``["2024GQ0000926",`` -- two quotes and one separator per element. + per_entry = max(widths) + 3 + admitted = (CAP - 2) // per_entry + share = acs / len(households) + limit = admitted / share + fractions = {} + for denominator in (1000, 30, 24, 20, 15, 10, 1): + selected = supplied / denominator + fractions[f"1/{denominator}"] = { + "selected_households": round(selected), + "acs_serialnos": round(selected * share), + "canonical_json_bytes": round(selected * share * per_entry), + "refuses": selected * share * per_entry > CAP, + } + document = { + "scope": "diagnostic; not a build, certification or release artifact", + "release_eligible": False, + "cap_bytes": CAP, + "cap_name": "acs_housing_universe_source.ACS_HU_RECEIPT_MAX_BYTES", + "guard": "acs_native_coverage_binding.py:563-565", + "serialno_widths_observed": widths, + "json_bytes_per_serialno": per_entry, + "serialnos_admitted": admitted, + "pilot_selection": { + "selected_households": len(households), + "acs": acs, + "asec": len(households) - acs, + "acs_share": round(share, 6), + "supplied_households": supplied, + }, + "binds_above_selected_households": round(limit), + "binds_above_share_of_source": round(limit / supplied, 6), + "transport_lane_lifted_ceiling_1": { + "households": 96860, + "share_of_source": 0.061, + "note": "this bound is LOWER, so it refuses first", + }, + "by_fraction": fractions, + } + pathlib.Path(sys.argv[1]).write_text(json.dumps(document, indent=2) + "\n") + print(f"serialno widths observed: {widths}") + print(f"json bytes per serialno : {per_entry}") + print(f"1 MiB admits : {admitted:,} ACS serialnos") + print( + f"ACS share of a selection: {acs}/{len(households)} = {share:.4f} " + "(recovered 1/1000 pilot)" + ) + print( + f"=> refuses above ~{round(limit):,} selected households " + f"({limit / supplied * 100:.2f}% of source), against the transport lane's " + "lifted 96,860 (6.10%)" + ) + for name, row in fractions.items(): + print( + f" {name:>7}: {row['selected_households']:>10,} selected, " + f"{row['acs_serialnos']:>10,} ACS -> {row['canonical_json_bytes']:>12,} B " + f"{'REFUSES' if row['refuses'] else 'fits'}" + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/native-retention-seal/adversarial-verification-receipt.json b/experiments/native-retention-seal/adversarial-verification-receipt.json new file mode 100644 index 000000000..de3084b16 --- /dev/null +++ b/experiments/native-retention-seal/adversarial-verification-receipt.json @@ -0,0 +1,458 @@ +{ + "scope": "diagnostic receipt of an adversarial verification pass; not a build, certification or release artifact", + "release_eligible": false, + "method": "Six independent review dimensions over the finished head -- accept-where-refuse, retention-roster completeness, executor invariants, document accuracy, battery completeness, refusal-code preservation -- each finding then put to TWO independent adversarial verifiers whose default answer is REFUTED, one judging mechanism and one judging consequence. A finding survives only if at least one verifier could not refute it.", + "agents": 68, + "agent_errors": 0, + "findings": 31, + "survived": 25, + "refuted": 6, + "dimensions": [ + "accept-where-refuse", + "retention-roster", + "executor-invariants", + "doc-accuracy", + "battery-completeness", + "refusal-preservation" + ], + "surviving_findings": [ + { + "dimension": "accept-where-refuse", + "title": "Seal ACCEPTS an object-axis pair the comparison REFUSES when a value's __eq__ refuses but its codec bytes match", + "file": "survey_population_replay.py", + "line": 405, + "severity_reported": "high", + "severity_after_verification": [ + "medium", + "medium" + ], + "both_verifiers_kept": true, + "claim": "_axis's AXIS arm is Index.identical, whose equals() for an object axis is an element-wise PyObject_RichCompareBool(x, y, Py_EQ) (pandas' array_equivalent_object). The seal replaces that predicate with a digest of _encode_object_scalar bytes (_axis_values_fold lines 405-410) and the byte arm (_series_seal on pd.Series(index.array)) uses the same codec, so BOTH arms of the seal are codec-byte equality. Any pair of object values whose codec bytes agree but whose == is False is therefore refused by same_replayed_population and accepted by the seal. The docstring at lines 398-399 asserts the fold 'is never weaker than equals'; that is false as written, and the same claim is repeated at docs/us-native-retention-seal.md:312.", + "failure_scenario": "Put the two indexes above on the person table of the fixture frame (tests' _with_person_axis) and build Populations from them. same_replayed_population(expected, actual) raises SURVEY_POPULATION_REPLAY_AXIS today; same_replayed_population_seals(replayed_population_seal(expected), replayed_population_seal(actual)) returns cleanly. A node whose object axis carries any int/str/float subclass with a custom __eq__ (or, on a platform where np.longdouble is wider than float64, two distinct longdoubles that pack to the same double) is no longer discriminated: the run accepts a replay the comparison refuses. Note the lane already recognised this exact hazard for axis NAMES -- _same_axis_seal lines 458-465 deliberately applies bool(one == other) per comparable rather than a tuple compare, pinned by test_a_comparable_whose_equality_refuses_itself_still_refuses -- but the axis VALUES fold was left as a digest.", + "disposition_kind": "code", + "disposition": "Object-axis fold rewritten to reproduce pandas' own equality classes; a value not `==` to the plain builtin the codec encodes it as now refuses AXIS at seal construction. Pinned by test_an_object_axis_value_with_its_own_equality_refuses_on_both_paths (2 cases); reverting the fold turns it red." + }, + { + "dimension": "accept-where-refuse", + "title": "Object-axis fold REFUSES a None-vs-NaN pair the comparison ACCEPTS, and the docs enumerate the added strictness as exactly two pairs", + "file": "survey_population_replay.py", + "line": 408, + "severity_reported": "medium", + "severity_after_verification": [ + "medium", + "low" + ], + "both_verifiers_kept": true, + "claim": "pandas' array_equivalent_object holds None and float('nan') interchangeable (its clause is `(x is None or is_nan(x)) and (y is None or is_nan(y))`; only pd.NA is separated, by the `(x is C_NA) ^ (y is C_NA)` test), and the byte arm re-infers both object axes to the same `str` Series of ['r','s',nan], so _axis ACCEPTS the pair. The seal's fold spells them apart (_object_bytes -> TAG_NONE vs TAG_FLOAT64+nan) and refuses AXIS. This is an acceptance turning into a refusal, not a refusal changing code. The docstring at lines 399-401 says the fold 'is stricter on exactly the differences the codec spells and == does not -- True against 1, -0.0 against 0.0', docs:313 repeats 'stricter on exactly those pairs', and docs:320-322 concludes 'None of the four is a narrowing ... item 4 is a refusal moving from one code to another'. None-vs-NaN is a third, unnamed, unpinned pair and it is not a code move. The docstring at lines 388-390 discusses only the None-vs-pd.NA case, which identical does refuse.", + "failure_scenario": "A node whose object axis holds None on the observed side and float('nan') on the reconstructed side (or vice versa) is accepted by same_replayed_population today and refused by same_replayed_population_seals with SURVEY_POPULATION_REPLAY_AXIS -- a green run turns red, which is the failure mode test_exotic_index_dtypes_agree_on_both_paths was written to guard ('a seal that is stricter than the predicate it replaces turns a green run red'). Secondary effect, also reproduced (fuzz iter 183): when such an axis pair coexists with a column defect, the seal now reports AXIS where the comparison reported SERIES_DTYPE_OR_LENGTH.", + "disposition_kind": "code", + "disposition": "Same rewrite: {None, NaN} is one class, as measured. Pinned by the 121-case test_the_object_axis_fold_reproduces_pandas_own_equality_classes sweep." + }, + { + "dimension": "accept-where-refuse", + "title": "np.asarray casts a masked-integer axis to float64, so the AXIS value fold is lossy above 2^53 and the refusal code moves to PRESENT_BITS", + "file": "survey_population_replay.py", + "line": 404, + "severity_reported": "medium", + "severity_after_verification": [ + "low", + "medium" + ], + "both_verifiers_kept": true, + "claim": "_axis_values_fold folds np.asarray(index.array). For a masked integer array carrying any null, numpy returns float64 (NA becomes NaN), so the fold of an Int64/UInt64 axis is a FLOAT fold: it then also takes the kind-'f' collapse branch at lines 413-416, and two distinct int64 labels that round to the same double fold identically. Index.equals compares the masked present values exactly, so identical refuses and the comparison reports AXIS while the seal falls through to the series arm and reports PRESENT_BITS. docs/us-native-retention-seal.md:314 states 'Every non-object axis kind is exact, including the three array_equivalent is byte-tolerant for' -- an Int64 axis with nulls is neither object nor exact, so that mechanism claim is wrong at this head, and docs:272 ('still refuses the same defect with the same code') does not hold for this pair.", + "failure_scenario": "Give the person table an Int64 (nullable) axis whose labels exceed 2^53 -- e.g. a hashed or concatenated source id -- and change one present label. Today the run refuses SURVEY_POPULATION_REPLAY_AXIS; with the seal it refuses SURVEY_POPULATION_REPLAY_PRESENT_BITS. Both refuse, so this is the lesser class, but the AXIS arm itself is silently non-exact for every masked-integer axis, and the design note asserts the opposite.", + "disposition_kind": "code", + "disposition": "Extension-dtype axes now fold through their exact object view. Pinned by test_a_masked_integer_axis_is_exact_above_two_to_the_fifty_three; dropping the view turns it red." + }, + { + "dimension": "accept-where-refuse", + "title": "A non-finite axis name moves the refusal from AXIS to UNSUPPORTED_AXIS_NAME", + "file": "survey_population_replay.py", + "line": 442, + "severity_reported": "low", + "severity_after_verification": [ + "none", + "low" + ], + "both_verifiers_kept": false, + "claim": "_axis evaluates identical() before _name_bytes(), so for an axis named float('nan') the name comparison inside identical fails first (nan != nan) and the pair refuses AXIS. _axis_seal calls _name_seal(index.name) while building each operand's seal, so the store grammar's refusal of a non-finite name fires first and the pair refuses UNSUPPORTED_AXIS_NAME. docs:293-295 (\u00a74 item 2) states that the unary assertions that now fire earlier do so 'with the same code'; this one does not, and the battery's parametrisation of test_an_axis_name_outside_the_store_grammar_refuses_on_both_paths (np.int64(5), Decimal('1'), b'bytes') misses it because for those names identical passes and the comparison also reaches _name_bytes.", + "failure_scenario": "Rename any table axis to float('nan') on both operands (the store refuses such a name downstream either way, so the run fails in both worlds): same_replayed_frame raises SURVEY_POPULATION_REPLAY_AXIS, while replayed_frame_seal raises SURVEY_POPULATION_REPLAY_UNSUPPORTED_AXIS_NAME when the observer seals the population. Refusal preserved, code changed, and \u00a74 item 2 says the code is preserved.", + "disposition_kind": "test+docs", + "disposition": "Pinned by test_a_non_finite_axis_name_refuses_on_both_paths_under_different_codes and recorded in the design note's residual risks as the one-sided-precedence class." + }, + { + "dimension": "retention-roster", + "title": "The roster is documented as \"three\" consumers; the base 19-node run declares one, and the count is configuration-dependent", + "file": "us-native-retention-seal.md", + "line": 371, + "severity_reported": "low", + "severity_after_verification": [ + "low", + "low" + ], + "both_verifiers_kept": true, + "claim": "All three authority documents state that the base financial run declares three consumers and that \"those three are retained as objects\". The code's roster expression has at most three terms, and how many are present depends on `property_income` and `rebase_property_taxes`: one node for the plain 19-node base run, two with property income and no rebase, three only with the tax rebase. The change's own new test computes one. The doc also mis-maps the code's second term: `property_graph.ATTACH_NODE` is gated on `property_graph is not None`, not on the rebase, and in the no-rebase case it is the *final node* (the doc's first role), not \"the property population\" (its third role).", + "failure_scenario": "A reader auditing \"which nodes still hold Population objects\" for the measured 19-node base configuration reads docs/us-native-retention-seal.md:371-375 (or the runner docstring at graph_atomic_survey_financial.py:1318-1319, \"rather than the three below\", or experiments/native-retention-seal/out.md:208-212, \"Those three are detached with the executor's own `_observer_snapshot`\") and looks for three retained objects. Evaluating the code at :1688-1697 with `property_income=None, rebase_property_taxes=False` yields `frozenset({'survey_predictors.attach'})` \u2014 one \u2014 which is exactly what the change's own test asserts at test_us_graph_atomic_survey_financial.py:336 and what out.md:228 prints. The same reader auditing the property-income-without-rebase configuration finds two, with the second node playing the doc's first role rather than its third.", + "disposition_kind": "docs", + "disposition": "The report now states the roster is one, two or three nodes by configuration, and that the measured nineteen-node run declares one." + }, + { + "dimension": "executor-invariants", + "title": "The new docstring withdraws only \"execution state\"; the store/cache guarantee is withdrawn too, and silently, durably, across runs", + "file": "executor.py", + "line": 2465, + "severity_reported": "medium", + "severity_after_verification": [ + "low", + "none" + ], + "both_verifiers_kept": false, + "claim": "The paragraph at 2458-2467 admits that in the new mode \"the executor no longer enforces that an observer cannot reach execution state, so a mutating observer in it would corrupt the run.\" The paragraph directly above it (2453-2454) promises two things, not one: \"changes to the snapshot cannot alter execution **or persistence**.\" The new admission names only the first. Measured, the second is gone as well, and its blast radius is not \"the run\": a mutating observer permanently poisons the content store under an unchanged address, and every later run that shares that store serves the poisoned bytes as a cache hit with an unchanged node key and an unchanged run key. No refusal fires, and the store's own payload digest is rewritten to match, so nothing can detect it afterwards.", + "failure_scenario": "A second caller adopts the mode with an observer that normalises in place before sealing (e.g. `population.frame.weights_for(\"household\").values` after `setflags(write=True)`, or an `.loc[:, col] +=` on a table it means to summarise). The observer runs at executor.py:2787-2791, i.e. before `_write_node` at 2793, so the poisoned population is what gets persisted. The run itself reports a key identical to a clean run's. Weeks later an unrelated, observer-free `run_graph` against the same store reports all-hits and the same run key and hands back the corrupted weights. The docstring the caller read told them the exposure ended with \"the run\".", + "disposition_kind": "code", + "disposition": "run_graph's docstring now withdraws BOTH guarantees by name -- execution and persistence -- and says the persistence damage outlives the run." + }, + { + "dimension": "executor-invariants", + "title": "test_a_seal_only_observer_receives_the_live_population's default-mode arm is vacuous: it compares one run's snapshots to a different run's frames", + "file": "test_graph_executor.py", + "line": 4491, + "severity_reported": "medium", + "severity_after_verification": [ + "low", + "low" + ], + "both_verifiers_kept": true, + "claim": "The `assert not any(...)` at 4491-4495 is meant to pin the other half of the contract \u2014 that the *default* mode does not hand out the executor's live tables. It cannot: `detached` is filled by the first run (4469-4475, store \"detached\") while `attached` is `manifest.populations[\"survey\"]` from the *second* run (4477-4485, store \"live\"). Two separate `run_graph` calls build their own DataFrames, so no object from run 1 can ever be `is`-identical to one from run 2, detached or not. The assertion is therefore true by construction, and the test's own docstring claim (4461, \"In the default mode the observer receives an independent copy\") and the report's claim are unsupported by it.", + "failure_scenario": "A future change makes `_observer_snapshot` return a shallow copy, or short-circuits it for some population shape, so the *default* observer starts receiving the executor's live tables \u2014 the exact regression this arm exists to catch, and the one the pre-existing test at 4182-4248 depends on not happening. `pytest packages/microcosm-graph/tests` stays green: the arm compares against a frame from a different run and passes regardless (demonstrated above by the strongest possible version of that regression, detachment as the identity function).", + "disposition_kind": "test", + "disposition": "Both arms of test_a_seal_only_observer_receives_the_live_population now compare within their own run; reducing _observer_snapshot to the identity turns it red." + }, + { + "dimension": "executor-invariants", + "title": "Stale line citation in the design note: `:2773-2774` is the base commit's numbering, not this head's", + "file": "us-native-retention-seal.md", + "line": 418, + "severity_reported": "low", + "severity_after_verification": [ + "low", + "low" + ], + "both_verifiers_kept": true, + "claim": "\u00a77's sentence about `_observer_snapshot` costing \"one full independent copy per reached node, cache hits included\" cites `(:2773-2774)` for the observer call site. At this head, executor.py:2773-2774 is the mass-receipt block (`) from error` / `normalized_receipt[\"mass\"] = {**existing_mass, **authored_mass}`) and has nothing to do with the observer. 2773-2774 is exactly where the call site sat at the base commit a64f7b733, before this change moved it; at this head it is 2787-2791. The adjacent citation in the same paragraph (`executor.py:356-408` for `_observer_snapshot`) is correct, so the stale one reads as authoritative.", + "failure_scenario": "A reviewer auditing \u00a77 against the head opens executor.py:2773-2774, finds the mass-receipt lines, and either concludes the note is describing code that no longer exists or, worse, goes looking for a call site that was removed. The governing standard for this change requires doc line numbers to be correct at this head.", + "disposition_kind": "docs", + "disposition": "Re-derived: the detachment is executor.py:373 inside _observer_snapshot at :356, and the per-node call is :2787-2791." + }, + { + "dimension": "doc-accuracy", + "title": "\u00a76 and \u00a77c conclude \"the US half of this change moves no key at all\" from a receipt revision that predates the lane's own inventory re-pin", + "file": "out.md", + "line": 414, + "severity_reported": "high", + "severity_after_verification": [ + "medium", + "medium" + ], + "both_verifiers_kept": true, + "claim": "The report's bolded conclusion \u2014 and the `base \u2192 us_only` row it now cites as direct proof \u2014 rests on `us_only = 1b0b915b0`, a mid-lane revision that predates BOTH the inventory re-pin (43fb39270) and the entire runner change. The re-pin is a US-half commit and it moves `inventory_sha256`, which `implementation_manifest` puts in every one of the ten stage manifests, so the US half on its own moves every node key and every store address. The report says the opposite of its own \u00a77c cause 2 and \u00a711 question 2(c).", + "failure_scenario": "Max reads \u00a76/\u00a711 Q2, picks option 2(b) \u2014 \"decouple them; the US half lands with no key movement at all\" \u2014 and lands the US half expecting node keys and store addresses to be stable. Because 43fb39270 sits in that half, `inventory_sha256` moves from 58513b5b\u2026 to 2f98c788\u2026 in all ten stage manifests, every node key downstream moves, and every store address is invalidated \u2014 the exact outcome the option was chosen to avoid. The `base \u2192 us_only` row cannot detect this because 1b0b915b0 does not contain the re-pin, and because the row only compares roster-module digests, not `inventory_sha256`, which the receipt records in a separate block.", + "disposition_kind": "docs", + "disposition": "Section 6 now gives the two-commit attribution: 9bef866c5 moves executor.py in all ten rosters, 43fb39270 moves inventory_sha256 in all ten manifests. The seal moves no key; the US HALF DOES. The receipt revision is relabelled seal_and_battery." + }, + { + "dimension": "doc-accuracy", + "title": "Eight line citations are the base branch's or point at unrelated code, in documents that promise head line numbers", + "file": "us-native-retention-seal.md", + "line": 83, + "severity_reported": "medium", + "severity_after_verification": [ + "medium", + "low" + ], + "both_verifiers_kept": true, + "claim": "Both documents open with \"Every line number is at this branch's head unless it names another\", but eight citations are not. Four \u00a71 section headers and one out.md citation are verbatim a64f7b733 line numbers, shifted by the `import hashlib` this change itself adds at survey_population_replay.py:10; `executor.py:2773-2774` and out.md's `(:1897)` are base line numbers that land on unrelated code at this head; and `:1339-1357` matches neither revision.", + "failure_scenario": "A reviewer following the note's own instruction to \"re-derive the ones you rely on\" opens executor.py:2773-2774 to check the per-node detachment claim and finds a mass-receipt `raise ... from error`; opens graph_atomic_survey_financial.py:1339-1357 to check that the retention flag has exactly one caller and never sees `_retain_every_node_population=True`; opens survey_population_replay.py:79 expecting NONCANONICAL_NULL_BACKING and finds PRESENT_BITS. The claims are all true at the correct lines, so every one of these reads wastes time or, worse, reads as a fabricated citation.", + "disposition_kind": "docs", + "disposition": "Seven citations re-derived and corrected; the design note now states that the seal's `import hashlib` shifted every line from 10 onward in that file." + }, + { + "dimension": "doc-accuracy", + "title": "\u00a74's table credits test_a_seal_only_observer_receives_the_live_population with a discrimination it cannot make", + "file": "out.md", + "line": 323, + "severity_reported": "medium", + "severity_after_verification": [ + "low", + "low" + ], + "both_verifiers_kept": true, + "claim": "The table says that test pins \"the observer really does receive the executor's own table objects, **and the default mode really does not**\". The second half is not pinned: the negative assertion compares the *detaching* run's observations against the *other* run's manifest population, two separate runs with separate ContentStores, so no object identity is possible whichever mode the first run used. The assertion passes identically with detachment turned off.", + "failure_scenario": "A future change makes the default mode stop detaching \u2014 say `_observer_snapshot` is short-circuited, or the ternary at executor.py:2790 is inverted \u2014 and `test_a_seal_only_observer_receives_the_live_population` stays green, because its negative arm compares objects across two runs and can never fail. The report told the reviewer that this test guards the default mode's detachment, so nobody looks for another guard. (`test_observer_snapshot_detaches_complete_population_storage` at 4251 and `test_mutating_and_retained_observers_cannot_change_execution_or_cache` at 4183 are the real guards; neither is what \u00a74's row cites.)", + "disposition_kind": "docs", + "disposition": "Section 4's table now credits the test with the seal-only arm only, and points at question 8." + }, + { + "dimension": "doc-accuracy", + "title": "Two internal cross-references survived the section renumber pointing at the wrong target", + "file": "out.md", + "line": 109, + "severity_reported": "low", + "severity_after_verification": [ + "low", + "low" + ], + "both_verifiers_kept": true, + "claim": "After the 4879fd5a2 renumber and the later insertion of \u00a72c and \u00a710 (the PR section), two pointers are still wrong: out.md:109 sends the reader for \u00a71's answer-(4) items 3 and 4 to \"\u00a711 question 1\", which is the inherited-contract-repair question; and out.md:977 calls round 2 of the diagnostic \"\u00a78a's third finding\", when \u00a78a numbers rounds and the round described is its second.", + "failure_scenario": "A reader following out.md:109 lands on \"Where should the inherited contract repair live?\" and concludes the report lost the adversarial-pass question, or answers the wrong one. A reader following out.md:977 lands on \u00a78a round 3 \u2014 the round that patches nothing \u2014 and reads it as the round that refused before it started, inverting the very attribution \u00a712 was rewritten to get right.", + "disposition_kind": "docs", + "disposition": "Section numbering fixed (tests 9, PR 10, questions 11, caveats 12) and five cross-references repointed." + }, + { + "dimension": "doc-accuracy", + "title": "\u00a77a says no figure in it is transcribed by hand, but the generator produces neither the replay row nor the delta column", + "file": "out.md", + "line": 445, + "severity_reported": "low", + "severity_after_verification": [ + "low", + "low" + ], + "both_verifiers_kept": true, + "claim": "before_after_table.py emits six of the table's seven rows and no delta column. The `required replay CPU s` row and the whole \"vs after\" column are hand-entered, and the script's own `whole-process peak RSS GB` row is dropped from the table \u2014 so the reproducibility claim is stronger than what the script does.", + "failure_scenario": "Someone re-runs before_after_table.py after a later measurement to refresh \u00a77a, gets six rows and no deltas, and either drops the replay row that the CPU argument rests on or re-types it \u2014 which is the transcription the sentence promises does not happen. A reviewer checking the claim finds the replay row is not derivable from the cited generator and doubts the rest of the table.", + "disposition_kind": "code", + "disposition": "before_after_table.py now derives the replay row and the delta column, and the report pastes its output verbatim." + }, + { + "dimension": "doc-accuracy", + "title": "\u00a711 question 3(b)'s index-retention cost mixes a full-source figure with a 1/10 figure", + "file": "out.md", + "line": 868, + "severity_reported": "low", + "severity_after_verification": [ + "low", + "medium" + ], + "both_verifiers_kept": true, + "claim": "\"nineteen person indexes at 1/10 are about 0.5 GB against the 29 GB the populations were\" compares a full-source index cost with a 1/10 population cost. At 8 bytes a row, 0.5 GB is nineteen indexes over the full-source person count; at 1/10 the same arithmetic gives about 0.05 GB. The 29 GB is the 1/10 population figure. Neither the person count nor 0.5 GB is derivable from any artifact under experiments/native-retention-seal/.", + "failure_scenario": "Max weighs option 3(b) \u2014 retain the axes so every axis code stays exact \u2014 and reads the cost as 0.5 GB against a 29 GB saving, i.e. 1.7% of what the change recovers. At a consistent fraction it is 0.05 GB against 29 GB, about 0.2%: an order of magnitude cheaper than the option is presented as being, which is the difference between \"not free\" and \"negligible\".", + "disposition_kind": "docs", + "disposition": "Question 3(b) now gives the full-source and the 1/10 figures separately instead of one of each." + }, + { + "dimension": "doc-accuracy", + "title": "The declared-consumer roster is described as three nodes; the shipped set has one, two or three, and the measured run has one", + "file": "out.md", + "line": 268, + "severity_reported": "low", + "severity_after_verification": [ + "low", + "low" + ], + "both_verifiers_kept": true, + "claim": "Both documents say the base financial run declares three consumers and that \"those three are detached with the executor's own `_observer_snapshot`\". The shipped `declared_consumers` is `{financial.ATTACH_NODE}` plus `property_graph.ATTACH_NODE` only when a property graph exists and `_tax_module().GATE_NODE` only when the rebase is on, so it holds one, two or three nodes \u2014 and the nineteen-node run the report measures holds exactly one, as the report's own receipt block four lines later shows.", + "failure_scenario": "A reader sizing the remaining retention takes three retained populations per run as the shipped behaviour \u2014 three detached snapshots and three `_population_stamp` calls \u2014 and then cannot reconcile it with \u00a77a's \"one `_observer_snapshot` instead of nineteen and one `_population_stamp` instead of nineteen\", which is the actual measured run. The two statements are three lines apart and describe different rosters.", + "disposition_kind": "docs", + "disposition": "Same as the roster finding above." + }, + { + "dimension": "doc-accuracy", + "title": "\"about 0.31 GiB\" is 0.31 GB (0.29 GiB), and neither it nor its inputs come from an artifact in this lane", + "file": "out.md", + "line": 539, + "severity_reported": "low", + "severity_after_verification": [ + "low", + "low" + ], + "both_verifiers_kept": true, + "claim": "The retention-size figure the report uses three times to dismiss the +6 GB replay-phase RSS difference is quoted in GiB but computed in GB, and both of its inputs (9.6-9.8 bytes per cell and 1.70e6 cells) come from the base lane's report prose rather than from any measurement JSON or receipt under experiments/native-retention-seal/.", + "failure_scenario": "A reader checking the one number that licenses \"this comparison is not evidence about retention in either direction\" recomputes 19 \u00d7 1.70e6 \u00d7 9.7 = 313 MB = 0.29 GiB, finds the report's own arithmetic off by 7%, and cannot re-derive either input from this lane's artifacts at all. The conclusion survives \u2014 0.29 GiB is still an order of magnitude below 6 GB \u2014 but a figure quoted three times as this lane's should be reproducible from this lane.", + "disposition_kind": "docs", + "disposition": "Corrected to 0.31 GB (0.29-0.30 GiB), with the arithmetic and the note that neither input is this lane's." + }, + { + "dimension": "battery-completeness", + "title": "\u00a73(a)'s \"dtype token\" is not the code, and the battery test named for it never calls the seal", + "file": "us-native-retention-seal.md", + "line": 215, + "severity_reported": "medium", + "severity_after_verification": [ + "medium", + "medium" + ], + "both_verifiers_kept": true, + "claim": "\u00a73(a) states that for S2/S3 \"the seal folds a dtype token (type(dtype).__module__, type(dtype).__qualname__, str(dtype), getattr(dtype, \"storage\", None), getattr(dtype, \"na_value\", ...) is pd.NA)\" and that \"the battery proves it by sweeping a dtype census and asserting the equivalence both ways\". No such token exists at this head, and the census test proves nothing about the seal: it never calls a seal function, and its two expressions are the same expression.", + "failure_scenario": "Delete both dtype arms from `_same_series_seal` (`left[0] is right[0] and left[1] == right[1]` at :353-356) and `test_the_dtype_token_is_faithful_to_the_predicate_it_replaces` still passes \u2014 it exercises no line of the seal. The only cases that would go red are three unrelated driver cases (`test_a_native_dtype_change_at_equal_values_still_refuses`, `test_observed_values_masks_and_dtypes_are_exact[dtype]`, `test_string_storage_and_null_policy_are_part_of_the_comparison`), so a reader auditing \"is the dtype token faithful for every admitted dtype?\" is pointed at a test that answers a question about pandas, not about this change. Worse, the token as documented would accept `np.longlong` against `np.int64` (equal module, qualname, str, storage, na_value), i.e. the doc describes a seal that fails closed less than the shipped one.", + "disposition_kind": "test+docs", + "disposition": "The census test now drives the seal for every ordered pair and is renamed _dtype_head_; replacing the retained head with str(dtype) turns it red. The note's section 3(a) rewritten to describe the retained objects." + }, + { + "dimension": "battery-completeness", + "title": "\u00a73(a)/\u00a76's `_comparables` digest and `repr()` fallback \u2014 and the whole \"residual risk\" paragraph \u2014 describe code that is not there", + "file": "us-native-retention-seal.md", + "line": 226, + "severity_reported": "medium", + "severity_after_verification": [ + "medium", + "medium" + ], + "both_verifiers_kept": true, + "claim": "\u00a73(a) says the axis seal folds \"the qualified class (__module__ + __qualname__ ...), the dtype token, and a digest over every name in type(index)._comparables\", with `name` through `_name_bytes` and \"any other comparable ... folded through `_name_bytes` when the store codec accepts it and through `repr()` otherwise\"; \u00a76 then spends its \"residual risk this note will not hide\" paragraph on that repr fallback. The seal does none of this: it retains the class object and the raw comparable values and compares them the way `identical` does, so the documented risk cannot occur and the documented mechanism does not exist.", + "failure_scenario": "A reader following \u00a76 looks for the repr fallback to bound the risk and finds nothing to read; a reader following \u00a73(a) expects `freq` to be digested and finds it retained as a live `DateOffset` compared with `==`. The battery contradicts the doc rather than the code: test_a_comparable_whose_equality_refuses_itself_still_refuses (test:1095-1112) passes only because comparables are compared with `==` \u2014 under the documented repr fold a `_Refusing(1.0)` name on both sides would repr-match and the pair would be accepted, so that test would go red.", + "disposition_kind": "docs", + "disposition": "The note's section 3(a) and section 6 rewritten: there is no _comparables digest and no repr() fallback. Section 6 now states the three real residual risks." + }, + { + "dimension": "battery-completeness", + "title": "out.md's reconciliation of 122 tests to 116 comparisons is wrong in both halves", + "file": "out.md", + "line": 136, + "severity_reported": "low", + "severity_after_verification": [ + "low", + "low" + ], + "both_verifiers_kept": true, + "claim": "out.md:135-137 says \"The file is 122 tests against 116 comparisons because six of them drive no comparison: three pin the codes this change adds (\u00a72c) and three are the O(columns) and snapshot-preservation properties.\" Nine collected items drive no comparison, not six; the snapshot-preservation test it names drives two comparisons and is in the receipt; and the arithmetic only closes because three other tests drive two comparisons each.", + "failure_scenario": "A reviewer auditing coverage subtracts the six named exemptions and concludes that every other one of the 122 tests is a driver case with a receipt row \u2014 so the four items that are genuinely unaudited by the driver (the flags-structure test, the dtype-census test, and the two RangeIndex params) are read as covered. It is the same arithmetic that hides finding 1.", + "disposition_kind": "docs", + "disposition": "Recomputed: 246 items, 113 driving at least one comparison, three of those driving two, 133 driving none, with the nine property tests named." + }, + { + "dimension": "battery-completeness", + "title": "out.md counts a pair among \"the 14 accepted pairs\" that the agreement driver never sees", + "file": "out.md", + "line": 172, + "severity_reported": "low", + "severity_after_verification": [ + "low", + "low" + ], + "both_verifiers_kept": true, + "claim": "out.md:166-174 says the 14 receipt-recorded acceptances \"include ... RangeIndex(0, 1, 1) against RangeIndex(0, 1, 7)\", and out.md:117-119 says the file \"now routes **every** mutation through an agreement driver\". The RangeIndex pairs are checked path-by-path, not through the driver, and contribute zero of the 116 rows.", + "failure_scenario": "The acceptance half is the half that catches a seal that has become stricter (a green run turned red). A reader reconciling the 14 against the prose looks for a RangeIndex row in the receipt and cannot find it, and the two exotic-axis and observer-snapshot acceptances that are actually in the 14 go unmentioned. Because the RangeIndex case is outside the driver, a future change that made `_axis_seal` fold start/stop/step would be caught by that test but would never appear as a receipt disagreement.", + "disposition_kind": "docs", + "disposition": "The report now says the RangeIndex pair is checked path by path, contributes none of the 116 rows, and is not one of the fourteen." + }, + { + "dimension": "battery-completeness", + "title": "All four \u00a71 field-inventory line citations are off by one at this head", + "file": "us-native-retention-seal.md", + "line": 83, + "severity_reported": "low", + "severity_after_verification": [ + "low", + "low" + ], + "both_verifiers_kept": true, + "claim": "The \u00a71 sub-section headers cite `:179-208` (population), `:132-176` (frame), `:121-129` (axis) and `:48-111` (series). At this head the four functions are at 180-209, 133-177, 122-130 and 49-112: every cited range starts on the blank line above the `def` and stops one line short of the function's last line. The note's own rule is \"Every line number is at this branch's head\".", + "failure_scenario": "A reviewer opening `:121-129` to check the axis inventory reads a range whose first line is blank and which excludes line 130 \u2014 the `_series` call over the axis array, which is precisely the row A5 the table at docs:117-126 lists (\"A5 | `_series` over the axis array | the S codes\"). Same for \u00a71d: `:48-111` cuts the closing paren of the NATIVE_BITS `_require` that row S15 names.", + "disposition_kind": "docs", + "disposition": "Same as the citation finding above." + }, + { + "dimension": "battery-completeness", + "title": "Nothing in the battery distinguishes the per-column NONCANONICAL_NULL_BACKING disjunction from a frame-wide flag, which \u00a73(c) says is the point", + "file": "us-native-retention-seal.md", + "line": 261, + "severity_reported": "low", + "severity_after_verification": [ + "low", + "none" + ], + "both_verifiers_kept": false, + "claim": "\u00a73(c) argues \"A single population-wide flag would not reproduce it: today's disjunction is evaluated per column, and one non-canonical column must not force whole-frame byte equality on the others\", and the code repeats it at :363-367. No battery case can tell the two designs apart: every existing masked case has either all columns canonical on the actual side or a difference that both designs refuse.", + "failure_scenario": "Replace `canonical` in `_series_seal` (:309, :317) with a single population-wide flag and hoist the disjunction out of `_same_series_seal` (:367): all 122 tests still pass, while the mixed frame above \u2014 accepted today \u2014 would be refused NONCANONICAL_NULL_BACKING. That is the green-run-turns-red direction the note says it is guarding against, and it is unpinned.", + "disposition_kind": "test", + "disposition": "test_the_canonical_null_disjunction_is_per_column_and_not_frame_wide added; making the flag pessimistic turns it red." + }, + { + "dimension": "refusal-preservation", + "title": "\u00a73(a) documents a \"dtype token\" the code does not implement, and \u00a74(1) says that token would be wrong", + "file": "us-native-retention-seal.md", + "line": 215, + "severity_reported": "medium", + "severity_after_verification": [ + "low", + "medium" + ], + "both_verifiers_kept": true, + "claim": "The design note's \u00a73(a) states that the seal replaces the S2/S3 dtype pair with a five-element token of strings and booleans. The implementation does no such thing: it retains the live dtype object and its class and applies the identical `is`/`==`. The note's own \u00a74(1) then argues that a spelling-based token would MISS a defect the code catches, so the two sections of the same authority describe mutually exclusive mechanisms and \u00a73(a) is the one that does not match the code read at this head.", + "failure_scenario": "A reader auditing fail-closedness for an `np.longlong` column follows \u00a73(a), computes the documented token for `np.longlong` and for `np.int64` \u2014 `('numpy', 'dtype[longlong]', 'int64', None, False)` vs `('numpy', 'dtype[int64]', 'int64', None, False)` \u2014 and reasons about a `__qualname__` string comparison that the shipped code never performs. Anyone porting the seal, or re-deriving the S2/S3 equivalence argument from the note rather than from `_same_series_seal`, reproduces the wrong predicate. The test that exists (`test_us_survey_population_replay.py:796-809`) asserts the real mechanism, `(type(left), left) == (type(right), right)`, not the documented five-tuple, so the note is stale against both the code and its own proof.", + "disposition_kind": "docs", + "disposition": "Same as the dtype-head finding above." + }, + { + "dimension": "refusal-preservation", + "title": "\u00a76's stated residual risk is a `repr()` comparable fallback that does not exist in the code", + "file": "us-native-retention-seal.md", + "line": 419, + "severity_reported": "medium", + "severity_after_verification": [ + "medium", + "medium" + ], + "both_verifiers_kept": true, + "claim": "\u00a76 \u2014 the fail-closed section that this audit's standard is written against \u2014 declares one residual risk: that the `_comparables` fold encodes a comparable through `repr()` when the axis-name codec will not take it, so the seal could refuse where `identical()` accepts. `_axis_seal` has no such fallback. It retains the raw comparable values and `_same_axis_seal` compares each one with `bool(one == other)`, which is exactly the predicate `Index.identical` applies. The declared risk therefore cannot occur, and the note states no residual risk for the mechanism actually shipped.", + "failure_scenario": "Reproduce by constructing an index class whose `_comparables` carries a value the store codec rejects, e.g. a `DatetimeIndex` whose `freq` is a `DateOffset`: `_axis_seal` stores the `DateOffset` object itself and `_same_axis_seal` compares two of them with `==`, so a pair that `identical()` accepts is accepted by the seal and the documented refuse-where-accept divergence never materialises. The concrete harm is the inverse of a missed defect: an owner reading \u00a76 to decide whether the seal is safe to ship is told to worry about a divergence that cannot happen, and is told nothing about the real property \u2014 that the comparables arm is now an `==` over retained live objects, which inherits `identical()`'s behaviour exactly but also keeps those objects alive inside the seal record for the life of the run.", + "disposition_kind": "docs", + "disposition": "Same as the residual-risk rewrite above." + }, + { + "dimension": "refusal-preservation", + "title": "The \u00a71 refusal-code tables cite base line numbers while claiming to be read off this head", + "file": "us-native-retention-seal.md", + "line": 83, + "severity_reported": "low", + "severity_after_verification": [ + "low", + "low" + ], + "both_verifiers_kept": true, + "claim": "\u00a71 is the enumeration of the forty-four discriminations and their codes \u2014 the index every later fail-closed claim points back to. Its header says the table was read off `survey_population_replay.py` \"at this head\", but all four of its line citations are the base commit's numbers. This change added `import hashlib` at line 10 of the module, shifting every one of the four cited functions down by one, so each cited range is one line short at HEAD.", + "failure_scenario": "Open the note, go to \u00a71a and jump to `survey_population_replay.py:179` expecting the first line of `same_replayed_population`; you land on line 179, the blank line before it, and the cited range `:179-208` stops one line short of the `DESIGN_BYTES` require at :209 \u2014 i.e. the range omits the last predicate in the table it is indexing (P11's byte comparison). Same one-line truncation at the end of each of the other three ranges: `:48-111` excludes the `NATIVE_BITS` require's closing line at :112, `:132-176` excludes :177, `:121-129` excludes :130.", + "disposition_kind": "docs", + "disposition": "Same as the citation finding above." + } + ], + "refuted_findings": [ + { + "dimension": "retention-roster", + "title": "The completion host's roster read depends on `_retain_every_node_population` with no check at the consumer; the existing parent guard does not imply it", + "severity_reported": "low", + "why_refuted": "I tried to refute the finding on facts first, and could not \u2014 every line citation is exact:\n\n- graph_survey_completion_host.py:311-314 is verbatim the `require(state.property_income is not None and not state.rebase_property_taxes, \"COMPLETION_ACTUAL_PROPERTY_PARENT\")` the finding quotes, and it is the only guard on the parent in `_CompletionHost.__init__`.\n- :814-816 is verbatim `base_expected = dict(zip(base.compiled.order, (p for p, _ in state.node_populations), strict=True))`, and :830 is verbatim `host.atomic.same_replayed_population(expected[node_id], observed[node_id])`.\n- The prose invariant is at graph_atomic_survey_financial.py:1318-1323, exactly as quoted.\n- I grepped for a guard at the consumer: `node_populations` appears in graph_survey_completion_host.py only at :815 (the read) and :907 (the child's own issue). Nothing validates the value types. I read `_CompletionHost.__init__` in full (307-487), `extend`/`_extend` (736-832), `_child_expected` (681-735) and `_check_observed_union` (185-190): no earlier refusal fires. `parent = base.financial_population` (:367) is a retained declared consumer, so it survives.\n- I computed the two mechanism claims rather than trusting t" + }, + { + "dimension": "executor-invariants", + "title": "test 2's warm parametrization pins no cache hit, unlike the test it is modelled on, so its \"cold and warm\" coverage is unverified", + "severity_reported": "low", + "why_refuted": "Three independent grounds for refutation, in order of force.\n\n1. The failure scenario is empirically false \u2014 the regression it names is not silent. The finding's scenario is \"a later change to the restore path ... stops the warm arm from hitting the cache. Both parametrizations then execute cold, the test stays green.\" I simulated exactly that by monkeypatching `microcosm.graph.executor._load_record` (the sole restore entry point, executor.py:1848, reached at 2591, which sets `hit = True` at 2615) to always raise `StoreMiss`. Baseline: 92/92 pass. Under the simulation: 30 tests fail, including `test_mutating_and_retained_observers_cannot_change_execution_or_cache[True]` failing precisely at line 4228 (`assert all(receipt.hit for receipt in observed.nodes.values()) is warm` \u2192 `assert False is True`). That model test uses the identical fixture shape the seal-only test uses \u2014 same `compiled = compile_graph(_graph(leaf=False))`, same \"pre-run into `store` when warm\" pattern at 4194-4197 vs 4425-4428. So the warm arm cannot degrade into a duplicate of the cold arm without the suite going loudly red; a reader of \u00a74 is never left with a silently-cold warm arm.\n\n2. No regression specific t" + }, + { + "dimension": "doc-accuracy", + "title": "\"The twenty-two refusal codes survey_population_replay.py raises (counted off the module)\" is 25 at this head", + "severity_reported": "low", + "why_refuted": "The reporter's number checks out (25 suffixes in the file at head, 22 at base) but the defect they build on it does not survive reading the surrounding document. The sentence at docs/us-native-retention-seal.md:155 sits under a heading that scopes it explicitly to what `same_replayed_population` compares *today*, and at this head that function still raises exactly 22 codes \u2014 the three extras live in the seal constructors and `seal_identity`, which \u00a71 is not about. So the \"22\" is not stale for its declared subject; only the parenthetical's shorthand (\"counted off the module\") is looser than the section it serves.\n\nThe failure scenario is also unreachable as described. A reader who greps the module and gets 25 finds all three extras named in \u00a76's added-codes table, each with the property it guards and the test that pins it, under a sentence that says the pre-change set is twenty-two and none of it is retired. And the \"right reading\" the finding says is never stated is stated twice in the note (\u00a71 heading, \u00a76:346-348) and a third time in out.md:18, whose wording \u2014 \"What `same_replayed_population` compares today. Forty-four rows under the twenty-two refusal codes...\" \u2014 is the very scop" + }, + { + "dimension": "battery-completeness", + "title": "The `[weight_kind]` population case never reaches the predicate it is named for; it refuses at the frame level", + "severity_reported": "medium", + "why_refuted": "The finding has one true premise and a false conclusion, and its stated failure scenario is demonstrably wrong.\n\nTrue premise: the `[weight_kind]` case of the provenance test does mutate the Frame's `Weights` kind as well as the population mapping, and it therefore refuses `WEIGHT_BYTES` inside `same_replayed_frame` (computed WEIGHT_BYTES; the committed receipt agrees). Its ordering claim about survey_population_replay.py is accurate.\n\nFalse conclusion: \"P5's value arm is never evaluated by any case in the battery\" / \"the predicate it names is untested\". Row P5 is, in the doc's own words, `tuple(weight_kind.items())` equality that is order-SENSITIVE \u2014 a single conjunct that fires on either a value or an order difference. The change adds `test_mapping_order_is_part_of_the_comparison[weight_kind]` (:745), which builds ONE frame, derives `expected` from it, and produces `actual` by `replace(expected, weight_kind=reversed_mapping)` \u2014 same Frame object, so `same_replayed_frame` passes trivially and the refusal comes from exactly the P5 conjunct and its seal counterpart, element [4]. That is a test mutating exactly that property in one of two otherwise-equal populations, pinning `POPULAT" + }, + { + "dimension": "battery-completeness", + "title": "The `[index_dtype]` case does not isolate the index dtype \u2014 it swaps the index class", + "severity_reported": "low", + "why_refuted": "The finding's observation about the test case is literally true and reproduces, but it fails three of the refutation grounds at once.\n\nFirst, it is pre-existing. The `[index_dtype]` id and the line that implements it (`pd.Index([0, 1], dtype=\"int32\")`) are byte-for-byte the same at base commit a64f7b733; a diff of the whole parametrize block base-vs-HEAD is empty. The change's only edit to that test swapped `with pytest.raises(ValueError, match=_ERROR): same_replayed_frame(...)` for `_refuses_frames(expected, actual)`, which now also requires the seal path to reach the identical refusal code. That is strictly more binding than what was there before, so the change did not introduce, widen, or weaken the conflation the finding describes.\n\nSecond, the coverage gap the finding infers does not exist. `_axis_seal` is a single function; `replayed_frame_seal` calls it at lines 495, 496 and 514 for each table's index, each table's columns axis, and the strata index. There is no separate \"index dtype\" branch to cover \u2014 element [3] is the same expression on every axis. The finding concedes that `test_the_columns_axis_dtype_is_part_of_the_comparison` holds the class constant and isolates the d" + }, + { + "dimension": "battery-completeness", + "title": "The one divergence the note discloses is the one class the agreement driver cannot record, and no test pins it", + "severity_reported": "low", + "why_refuted": "The divergence the finding rests on is genuine \u2014 I reproduced both example pairs with the worktree interpreter and got exactly `direct='SURVEY_POPULATION_REPLAY_OBJECT_VALUE'`, `seal='SURVEY_POPULATION_REPLAY_AXIS'` \u2014 and the agreement driver does assert `direct == sealed` (test line 98), so the pair cannot ride through `_agree_frames`. It is also true that battery-receipt.json carries no divergence field. That is where the finding stops being right.\n\nFirst, \"such a pair cannot be added to the battery\" and \"the only test shape available for that axis kind is one the driver rejects\" are both refuted by the changed file itself. This change added the imports of `_axis`, `_axis_seal` and `_same_axis_seal` (lines 16-18) and a test that uses them directly, bypassing the driver: `test_range_index_parameters_that_no_label_shows_are_accepted` asserts `_verdict(_same_axis_seal, _axis_seal(one), _axis_seal(other)) is None` and `_verdict(_axis, one, other) is None` (lines 1091-1092). The divergent pair is pinnable in exactly that shape, in the same file, with no driver change. So the absence of a pin is not a structural consequence of the driver's design, as the finding argues.\n\nSecond, the fa" + } + ] +} diff --git a/experiments/native-retention-seal/agreement-fuzz-receipt.json b/experiments/native-retention-seal/agreement-fuzz-receipt.json new file mode 100644 index 000000000..f006e3113 --- /dev/null +++ b/experiments/native-retention-seal/agreement-fuzz-receipt.json @@ -0,0 +1,20 @@ +{ + "scope": "diagnostic agreement sweep; not a build, certification or release artifact", + "release_eligible": false, + "seed": 20260918, + "rounds_requested": 4000, + "pairs_compared": 3852, + "disagreements": [], + "verdicts_reached": { + "SURVEY_POPULATION_REPLAY_AXIS": 2842, + "None": 466, + "SURVEY_POPULATION_REPLAY_MASKED_STORAGE": 130, + "SURVEY_POPULATION_REPLAY_OBJECT_VALUE": 112, + "SURVEY_POPULATION_REPLAY_PRESENT_BITS": 99, + "SURVEY_POPULATION_REPLAY_STRING_MASK": 91, + "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH": 49, + "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING": 46, + "SURVEY_POPULATION_REPLAY_STRING_VALUE": 16, + "SURVEY_POPULATION_REPLAY_NATIVE_BITS": 1 + } +} diff --git a/experiments/native-retention-seal/agreement_fuzz.py b/experiments/native-retention-seal/agreement_fuzz.py new file mode 100644 index 000000000..4de49def6 --- /dev/null +++ b/experiments/native-retention-seal/agreement_fuzz.py @@ -0,0 +1,262 @@ +"""A seeded sweep for any surviving disagreement between the two paths. + +The battery drives 116 hand-built comparisons and a 121-case sweep of the +measured object-axis equality classes. This is the wider net: a deterministic +pseudo-random walk over axis kinds, axis values, column kinds and column +mutations, driving every pair through ``same_replayed_frame`` and through the +seal and recording any pair where the two verdicts differ. + +An earlier adversarial pass found three real divergences this way, two of them +in the accept/refuse directions, so the sweep is committed rather than +described: a disagreement it reports is a finding, and the receipt names it. + + python experiments/native-retention-seal/agreement_fuzz.py OUT.json [ROUNDS] +""" + +import json +import pathlib +import random +import sys + +import numpy as np +import pandas as pd + +ROOT = pathlib.Path(__file__).resolve().parents[2] +sys.path[:0] = [str(ROOT / p) for p in sorted((ROOT / "packages").glob("*/src"))] +sys.path.insert(0, str(ROOT / "packages/microcosm-build/tests")) + +import test_us_survey_population_replay as battery # noqa: E402 + +from microcosm.build.us_runtime.survey_population_replay import ( # noqa: E402 + replayed_frame_seal, + same_replayed_frame, + same_replayed_frame_seals, +) + +# Values the store codec admits, plus the null sentinels, plus the two shapes +# `==` holds equal that the codec spells apart. +_POOL = [ + None, + float("nan"), + pd.NA, + pd.NaT, + True, + False, + 0, + 1, + -0.0, + 0.0, + 1.0, + 2**53, + 2**53 + 1, + float("inf"), + float("-inf"), + "a", + "", + b"a", + np.int64(1), + np.float64(1.0), + np.bool_(True), +] +_AXES = ("object", "int64", "Int64", "string", "boolean", "float64", "datetime") + + +def _axis(rng, length): + kind = rng.choice(_AXES) + if kind == "object": + return pd.Index([rng.choice(_POOL) for _ in range(length)], dtype=object) + if kind == "int64": + return pd.Index( + [rng.randrange(-(2**60), 2**60) for _ in range(length)], dtype="int64" + ) + if kind == "Int64": + return pd.Index( + pd.array( + [ + None if rng.random() < 0.3 else rng.randrange(0, 2**60) + for _ in range(length) + ], + dtype="Int64", + ) + ) + if kind == "string": + return pd.Index( + pd.array( + [ + None if rng.random() < 0.3 else rng.choice("abc") + for _ in range(length) + ], + dtype="string", + ) + ) + if kind == "boolean": + return pd.Index( + pd.array( + [ + None if rng.random() < 0.3 else rng.random() < 0.5 + for _ in range(length) + ], + dtype="boolean", + ) + ) + if kind == "float64": + return pd.Index( + [float(rng.choice([0.0, -0.0, 1.5, float("nan")])) for _ in range(length)], + dtype="float64", + ) + return pd.DatetimeIndex( + [f"2020-01-{1 + rng.randrange(0, 28):02d}" for _ in range(length)] + ) + + +def _zero_hidden_backing(frame, rng): + """What a store round trip does: zero the bytes beneath a null mask.""" + column = rng.choice(["nullable_integer", "nullable_boolean"]) + frame.person[column].array._data[frame.person[column].array._mask] = 0 + return frame + + +def _flip_hidden_backing(frame, rng): + column = rng.choice(["nullable_integer", "nullable_boolean"]) + data = frame.person[column].array._data + data[frame.person[column].array._mask] = rng.randrange(1, 90) + return frame + + +def _flip_present_value(frame, rng): + data = frame.person["nullable_integer"].array._data + data[~frame.person["nullable_integer"].array._mask] = rng.randrange(1, 90) + return frame + + +def _flip_mask(frame, rng): + mask = frame.person["nullable_integer"].array._mask + mask[rng.randrange(0, len(mask))] ^= True + return frame + + +def _retype_native(frame, rng): + tables = {entity: frame.table(entity).copy() for entity in frame.entities} + tables["person"]["native_float"] = tables["person"]["native_float"].astype( + rng.choice(["float32", "int64", "float64"]) + ) + return battery._rebuild(frame, tables=tables) + + +def _retype_text(frame, rng): + tables = {entity: frame.table(entity).copy() for entity in frame.entities} + tables["person"]["text"] = pd.array( + [rng.choice([None, "a", "b", ""]) for _ in range(len(tables["person"]))], + dtype="string", + ) + return battery._rebuild(frame, tables=tables) + + +def _retype_object(frame, rng): + tables = {entity: frame.table(entity).copy() for entity in frame.entities} + tables["person"]["object_value"] = pd.Series( + [rng.choice(_POOL) for _ in range(len(tables["person"]))], + index=tables["person"].index, + dtype=object, + ) + return battery._rebuild(frame, tables=tables) + + +def _untouched(frame, rng): + return frame + + +_COLUMN_MUTATIONS = ( + _untouched, + _untouched, + _zero_hidden_backing, + _flip_hidden_backing, + _flip_present_value, + _flip_mask, + _retype_native, + _retype_text, + _retype_object, +) + + +def _verdict(call, *arguments): + try: + call(*arguments) + except ValueError as error: + return str(error) + return None + + +def _sealed(expected, actual): + try: + one, other = replayed_frame_seal(expected), replayed_frame_seal(actual) + except ValueError as error: + return str(error) + return _verdict(same_replayed_frame_seals, one, other) + + +def main(): + out = pathlib.Path(sys.argv[1]) + rounds = int(sys.argv[2]) if len(sys.argv) > 2 else 600 + rng = random.Random(20260918) + base = battery._frame() + length = len(base.person) + disagreements, verdicts = [], {} + for index in range(rounds): + left, right = _axis(rng, length), _axis(rng, length) + if rng.random() < 0.25: + right = left # equal axes, so a column mutation is what differs + try: + expected = battery._with_person_axis(base, left) + actual = battery._with_person_axis(base, right) + except Exception: # an axis pandas will not accept on this table + continue + # Reach the series arm as well as the axis arm: mutate one column of + # the actual side the way the store or a defect would. + mutation = rng.choice(_COLUMN_MUTATIONS) + try: + actual = mutation(actual, rng) + except Exception: + continue + direct = _verdict(same_replayed_frame, expected, actual) + sealed = _sealed(expected, actual) + verdicts[str(direct)] = verdicts.get(str(direct), 0) + 1 + if direct != sealed: + disagreements.append( + { + "round": index, + "left": repr(list(left))[:200], + "right": repr(list(right))[:200], + "object_path": direct, + "seal_path": sealed, + } + ) + out.write_text( + json.dumps( + { + "scope": ( + "diagnostic agreement sweep; not a build, certification or " + "release artifact" + ), + "release_eligible": False, + "seed": 20260918, + "rounds_requested": rounds, + "pairs_compared": sum(verdicts.values()), + "disagreements": disagreements, + "verdicts_reached": dict( + sorted(verdicts.items(), key=lambda item: -item[1]) + ), + }, + indent=2, + ) + + "\n" + ) + print(f"pairs={sum(verdicts.values())} disagreements={len(disagreements)}") + for code, count in sorted(verdicts.items(), key=lambda item: -item[1]): + print(f" {count:5d} {code}") + for row in disagreements[:10]: + print(" DISAGREE", json.dumps(row)[:220]) + + +if __name__ == "__main__": + main() diff --git a/experiments/native-retention-seal/battery-receipt.json b/experiments/native-retention-seal/battery-receipt.json new file mode 100644 index 000000000..25127a5f1 --- /dev/null +++ b/experiments/native-retention-seal/battery-receipt.json @@ -0,0 +1,3421 @@ +{ + "scope": "diagnostic receipt of the discrimination battery; not a build, certification or release artifact", + "release_eligible": false, + "pytest_summary": "248 passed in 1.39s", + "comparisons": 564, + "agreements": 564, + "disagreements": [], + "unreachable_codes": { + "SURVEY_POPULATION_REPLAY_FRAME_TYPE": "Population validates frame is a Frame (population.py), so no Population can carry a non-Frame", + "SURVEY_POPULATION_REPLAY_STRING_POLICY": "StringDtype.__eq__ compares storage and na_value, so SERIES_DTYPE_OR_LENGTH fires first" + }, + "by_verdict": { + "SURVEY_POPULATION_REPLAY_AXIS": 402, + "SURVEY_POPULATION_REPLAY_OBJECT_VALUE": 43, + "ACCEPTED (both paths)": 42, + "SURVEY_POPULATION_REPLAY_NATIVE_BITS": 13, + "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT": 12, + "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT": 9, + "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING": 7, + "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH": 6, + "SURVEY_POPULATION_REPLAY_AXIS_NAME": 6, + "SURVEY_POPULATION_REPLAY_MASKED_STORAGE": 5, + "SURVEY_POPULATION_REPLAY_WEIGHT_BYTES": 4, + "SURVEY_POPULATION_REPLAY_UNSUPPORTED_AXIS_NAME": 3, + "SURVEY_POPULATION_REPLAY_STRING_VALUE": 2, + "SURVEY_POPULATION_REPLAY_UNSUPPORTED_EXTENSION_DTYPE": 2, + "SURVEY_POPULATION_REPLAY_DESIGN_BYTES": 2, + "SURVEY_POPULATION_REPLAY_PRESENT_BITS": 1, + "SURVEY_POPULATION_REPLAY_UNSUPPORTED_OBJECT": 1, + "SURVEY_POPULATION_REPLAY_TABLE_TYPE_OR_FLAGS": 1, + "SURVEY_POPULATION_REPLAY_POPULATION_TYPE": 1, + "SURVEY_POPULATION_REPLAY_STRATA_NAME": 1, + "SURVEY_POPULATION_REPLAY_STRING_MASK": 1 + }, + "rows": [ + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_comparable_whose_equality_refuses_itself_still_refuses", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_declared_link_table_refuses_on_both_paths", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_degenerate_mask_dtype_refuses_though_both_sides_carry_it", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_MASKED_STORAGE", + "seal_path": "SURVEY_POPULATION_REPLAY_MASKED_STORAGE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_masked_backing_that_is_falsy_but_not_zero_is_not_canonical", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING", + "seal_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_masked_integer_axis_is_exact_above_two_to_the_fifty_three", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_masked_integer_axis_is_exact_above_two_to_the_fifty_three", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_mass_change_record_subclass_refuses_though_the_values_match", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_mass_record_subclass_refuses_though_the_values_match", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_native_dtype_change_at_equal_values_still_refuses", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH", + "seal_path": "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_non_pandas_masked_carrier_refuses_though_the_bytes_match[pyarrow]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_MASKED_STORAGE", + "seal_path": "SURVEY_POPULATION_REPLAY_MASKED_STORAGE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_non_pandas_masked_carrier_refuses_though_the_bytes_match[sparse]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_MASKED_STORAGE", + "seal_path": "SURVEY_POPULATION_REPLAY_MASKED_STORAGE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_population_subclass_refuses_though_the_content_matches", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_POPULATION_TYPE", + "seal_path": "SURVEY_POPULATION_REPLAY_POPULATION_TYPE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_series_subclass_column_refuses_though_the_values_match", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH", + "seal_path": "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_str_subclass_cell_refuses_though_the_characters_match", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_STRING_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_STRING_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_string_columns_missing_mask_alone_is_part_of_the_comparison", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_STRING_MASK", + "seal_path": "SURVEY_POPULATION_REPLAY_STRING_MASK" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_a_structured_dtype_carrying_an_object_field_refuses_as_native_bits", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_actual_store_roundtrip_accepts_canonical_nulls_and_typed_objects", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_actual_store_roundtrip_accepts_canonical_nulls_and_typed_objects", + "operand": "population", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_axis_byte_difference_equals_does_not_see_keeps_the_series_code", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_axis_byte_difference_equals_tolerates_keeps_the_series_code[bool]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_axis_byte_difference_equals_tolerates_keeps_the_series_code[complex]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_axis_byte_difference_equals_tolerates_keeps_the_series_code[float]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_axis_dtype_class_difference_keeps_the_series_code", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH", + "seal_path": "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_axis_name_outside_the_store_grammar_refuses_on_both_paths[bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_UNSUPPORTED_AXIS_NAME", + "seal_path": "SURVEY_POPULATION_REPLAY_UNSUPPORTED_AXIS_NAME" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_axis_name_outside_the_store_grammar_refuses_on_both_paths[name0]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_UNSUPPORTED_AXIS_NAME", + "seal_path": "SURVEY_POPULATION_REPLAY_UNSUPPORTED_AXIS_NAME" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_axis_name_outside_the_store_grammar_refuses_on_both_paths[name1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_UNSUPPORTED_AXIS_NAME", + "seal_path": "SURVEY_POPULATION_REPLAY_UNSUPPORTED_AXIS_NAME" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_axis_nan_payload_difference_keeps_the_series_code", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_ndarray_subclass_backing_refuses_though_both_sides_carry_it", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_MASKED_STORAGE", + "seal_path": "SURVEY_POPULATION_REPLAY_MASKED_STORAGE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_object_axis_keeps_its_null_sentinel_identity", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_object_axis_value_with_its_own_equality_refuses_on_both_paths[_PickyInt]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_object_axis_value_with_its_own_equality_refuses_on_both_paths[_PickyInt]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_object_axis_value_with_its_own_equality_refuses_on_both_paths[_RefusingInt]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_object_axis_value_with_its_own_equality_refuses_on_both_paths[_RefusingInt]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_observer_snapshot_preserves_the_replay_seal", + "operand": "population", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_an_observer_snapshot_preserves_the_replay_seal", + "operand": "population", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_axes_schema_and_strata_are_exact[column_axis_name]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_axes_schema_and_strata_are_exact[columns]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_axes_schema_and_strata_are_exact[index_dtype]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_axes_schema_and_strata_are_exact[index_name]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_axes_schema_and_strata_are_exact[rows]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_axes_schema_and_strata_are_exact[schema_order]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_axes_schema_and_strata_are_exact[strata]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_axis_names_preserve_store_scalar_types[-0.0-0.0-columns]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS_NAME", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS_NAME" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_axis_names_preserve_store_scalar_types[-0.0-0.0-index]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS_NAME", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS_NAME" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_axis_names_preserve_store_scalar_types[True-1-columns]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS_NAME", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS_NAME" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_axis_names_preserve_store_scalar_types[True-1-index]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS_NAME", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS_NAME" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_axis_names_preserve_store_scalar_types[before2-after2-columns]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS_NAME", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS_NAME" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_axis_names_preserve_store_scalar_types[before2-after2-index]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS_NAME", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS_NAME" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_equal_unsupported_store_values_still_refuse[category]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_UNSUPPORTED_EXTENSION_DTYPE", + "seal_path": "SURVEY_POPULATION_REPLAY_UNSUPPORTED_EXTENSION_DTYPE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_equal_unsupported_store_values_still_refuse[nullable_float]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_UNSUPPORTED_EXTENSION_DTYPE", + "seal_path": "SURVEY_POPULATION_REPLAY_UNSUPPORTED_EXTENSION_DTYPE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_equal_unsupported_store_values_still_refuse[object]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_UNSUPPORTED_OBJECT", + "seal_path": "SURVEY_POPULATION_REPLAY_UNSUPPORTED_OBJECT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_exotic_index_dtypes_agree_on_both_paths[Int64-Int64-True]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_exotic_index_dtypes_agree_on_both_paths[Int64-Int64-mask-False]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_exotic_index_dtypes_agree_on_both_paths[Int64-Int64-value-False]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_exotic_index_dtypes_agree_on_both_paths[datetime-datetime-True]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_exotic_index_dtypes_agree_on_both_paths[datetime-datetime-nat-False]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_exotic_index_dtypes_agree_on_both_paths[string-string-True]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_exotic_index_dtypes_agree_on_both_paths[string-string-value-False]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_frame_context_and_exact_weight_contract_are_preserved[mass_log]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_frame_context_and_exact_weight_contract_are_preserved[metadata_scalar_type]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_frame_context_and_exact_weight_contract_are_preserved[metadata_signed_zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_frame_context_and_exact_weight_contract_are_preserved[nested_metadata]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_frame_context_and_exact_weight_contract_are_preserved[weight_bits]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_WEIGHT_BYTES", + "seal_path": "SURVEY_POPULATION_REPLAY_WEIGHT_BYTES" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_frame_context_and_exact_weight_contract_are_preserved[weight_kind]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_WEIGHT_BYTES", + "seal_path": "SURVEY_POPULATION_REPLAY_WEIGHT_BYTES" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_frame_context_and_exact_weight_contract_are_preserved[weight_signed_zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_WEIGHT_BYTES", + "seal_path": "SURVEY_POPULATION_REPLAY_WEIGHT_BYTES" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_hidden_storage_exception_is_directional_and_whole_column[noncanonical-nullable_boolean]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING", + "seal_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_hidden_storage_exception_is_directional_and_whole_column[noncanonical-nullable_integer]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING", + "seal_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_hidden_storage_exception_is_directional_and_whole_column[partial_canonical-nullable_boolean]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING", + "seal_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_hidden_storage_exception_is_directional_and_whole_column[partial_canonical-nullable_integer]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING", + "seal_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_hidden_storage_exception_is_directional_and_whole_column[reverse-nullable_boolean]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING", + "seal_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_hidden_storage_exception_is_directional_and_whole_column[reverse-nullable_integer]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING", + "seal_path": "SURVEY_POPULATION_REPLAY_NONCANONICAL_NULL_BACKING" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_index_comparables_beyond_the_name_are_part_of_the_comparison", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_mapping_order_is_part_of_the_comparison[design_weights]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_mapping_order_is_part_of_the_comparison[weight_kind]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_metadata_key_order_is_part_of_the_comparison", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_multiindex_outside_reviewed_store_profile_refuses", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_native_nan_payload_bits_are_part_of_the_comparison", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_native_signed_zero_and_nan_payload_bits_cannot_change[0-float32-bits1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_native_signed_zero_and_nan_payload_bits_cannot_change[0-float64-bits0]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_native_signed_zero_and_nan_payload_bits_cannot_change[1-float32-bits1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_native_signed_zero_and_nan_payload_bits_cannot_change[1-float64-bits0]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_non_finite_metadata_keeps_its_sign_on_both_paths", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_non_finite_metadata_keeps_its_sign_on_both_paths", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_FRAME_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_object_nan_payload_bits_cannot_change", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_object_nan_sign_is_part_of_the_comparison", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_object_scalar_equivalence_uses_actual_store_types[before0-7]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_object_scalar_equivalence_uses_actual_store_types[before1-True]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_object_scalar_equivalence_uses_actual_store_types[before2-1.25]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_object_scalar_equivalence_uses_actual_store_types[x-x]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_object_scalar_types_null_sentinels_and_float_bits_cannot_change[-0.0-0.0]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_object_scalar_types_null_sentinels_and_float_bits_cannot_change[1-1.0]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_object_scalar_types_null_sentinels_and_float_bits_cannot_change[None-after2]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_object_scalar_types_null_sentinels_and_float_bits_cannot_change[True-1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_object_scalar_types_null_sentinels_and_float_bits_cannot_change[before3-None]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_object_scalar_types_null_sentinels_and_float_bits_cannot_change[x-x]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_observed_values_masks_and_dtypes_are_exact[dtype]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH", + "seal_path": "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_observed_values_masks_and_dtypes_are_exact[mask]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_MASKED_STORAGE", + "seal_path": "SURVEY_POPULATION_REPLAY_MASKED_STORAGE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_observed_values_masks_and_dtypes_are_exact[membership]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_observed_values_masks_and_dtypes_are_exact[text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_STRING_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_STRING_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_observed_values_masks_and_dtypes_are_exact[value]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_PRESENT_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_PRESENT_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_one_sided_population_type_assertions_refuse_on_both_paths[mass_ledger-value2]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_one_sided_population_type_assertions_refuse_on_both_paths[mass_ledger-value3]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_one_sided_population_type_assertions_refuse_on_both_paths[owners-value0]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_one_sided_population_type_assertions_refuse_on_both_paths[version-7]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_one_sided_population_type_assertions_refuse_on_both_paths[weight_kind-value1]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_owner_mapping_order_alone_is_accepted_by_both_paths", + "operand": "population", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_population_provenance_and_original_design_bytes_are_exact[design_signed_zero]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_DESIGN_BYTES", + "seal_path": "SURVEY_POPULATION_REPLAY_DESIGN_BYTES" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_population_provenance_and_original_design_bytes_are_exact[design_value]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_DESIGN_BYTES", + "seal_path": "SURVEY_POPULATION_REPLAY_DESIGN_BYTES" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_population_provenance_and_original_design_bytes_are_exact[ledger]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_population_provenance_and_original_design_bytes_are_exact[missing_design]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_population_provenance_and_original_design_bytes_are_exact[owner]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_population_provenance_and_original_design_bytes_are_exact[version]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT", + "seal_path": "SURVEY_POPULATION_REPLAY_POPULATION_CONTEXT" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_population_provenance_and_original_design_bytes_are_exact[weight_kind]", + "operand": "population", + "object_path": "SURVEY_POPULATION_REPLAY_WEIGHT_BYTES", + "seal_path": "SURVEY_POPULATION_REPLAY_WEIGHT_BYTES" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_quiet_and_signalling_nan_are_distinguished", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS", + "seal_path": "SURVEY_POPULATION_REPLAY_NATIVE_BITS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_strata_index_name_is_part_of_the_comparison", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_string_storage_and_null_policy_are_part_of_the_comparison[pyarrow]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH", + "seal_path": "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_string_storage_and_null_policy_are_part_of_the_comparison[python]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH", + "seal_path": "SURVEY_POPULATION_REPLAY_SERIES_DTYPE_OR_LENGTH" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_table_flags_are_part_of_the_comparison", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_TABLE_TYPE_OR_FLAGS", + "seal_path": "SURVEY_POPULATION_REPLAY_TABLE_TYPE_OR_FLAGS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_canonical_null_disjunction_is_per_column_and_not_frame_wide", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_columns_axis_dtype_is_part_of_the_comparison", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_exact_index_class_is_part_of_the_comparison", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-+inf]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[+inf-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf--inf]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[-inf-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-2**53+1]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53+1-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-2**53]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-2**53]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[2**53-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-bytes]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[bytes-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-null]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-null]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-null]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-null]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-null]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[null-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-one]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[one-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-pd.NA]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NA-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-pd.NaT]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[pd.NaT-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-text]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[text-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-+inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero--inf]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-2**53+1]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-2**53]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-bytes]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-null]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-one]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-pd.NA]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-pd.NaT]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-text]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_AXIS", + "seal_path": "SURVEY_POPULATION_REPLAY_AXIS" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE", + "seal_path": "SURVEY_POPULATION_REPLAY_OBJECT_VALUE" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_object_axis_fold_reproduces_pandas_own_equality_classes[zero-zero]", + "operand": "frame", + "object_path": null, + "seal_path": null + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_the_strata_name_is_part_of_the_comparison", + "operand": "frame", + "object_path": "SURVEY_POPULATION_REPLAY_STRATA_NAME", + "seal_path": "SURVEY_POPULATION_REPLAY_STRATA_NAME" + }, + { + "test": "packages/microcosm-build/tests/test_us_survey_population_replay.py::test_unchanged_noncanonical_hidden_storage_is_accepted", + "operand": "frame", + "object_path": null, + "seal_path": null + } + ] +} diff --git a/experiments/native-retention-seal/battery_receipt.py b/experiments/native-retention-seal/battery_receipt.py new file mode 100644 index 000000000..8af0c6f78 --- /dev/null +++ b/experiments/native-retention-seal/battery_receipt.py @@ -0,0 +1,106 @@ +"""Rebuild the discrimination battery's receipt from the battery's own rows. + +The test file appends one JSON row per driven comparison when +``MICROCOSM_BATTERY_RECEIPT`` names a path -- the test name, which operand was +compared, the object path's verdict and the seal path's. This runs the battery +with that hook on and aggregates those rows, so every figure the report quotes +about the battery (``comparisons``, ``agreements``, ``by_verdict``) is derived +here rather than counted by hand. + + python experiments/native-retention-seal/battery_receipt.py OUT.json + +``unreachable_codes`` is the one field that is not a count: it is a claim about +why two of the module's codes cannot be reached, each measured once and carried +forward with its reason. The tests that pin the three codes this change *adds* +drive no comparison -- they are one-sided guards on a malformed seal record, +with no counterpart on the object path -- so they add no row and the comparison +count is unchanged by them. +""" + +import collections +import json +import pathlib +import subprocess +import sys +import tempfile + +ROOT = pathlib.Path(__file__).resolve().parents[2] +BATTERY = "packages/microcosm-build/tests/test_us_survey_population_replay.py" +UNREACHABLE = { + "SURVEY_POPULATION_REPLAY_FRAME_TYPE": ( + "Population validates frame is a Frame (population.py), so no " + "Population can carry a non-Frame" + ), + "SURVEY_POPULATION_REPLAY_STRING_POLICY": ( + "StringDtype.__eq__ compares storage and na_value, so " + "SERIES_DTYPE_OR_LENGTH fires first" + ), +} + + +def main(): + out = pathlib.Path(sys.argv[1]) + with tempfile.TemporaryDirectory() as scratch: + rows_path = pathlib.Path(scratch) / "rows.jsonl" + completed = subprocess.run( + [str(ROOT / ".venv/bin/python"), "-m", "pytest", BATTERY], + cwd=ROOT, + capture_output=True, + text=True, + env={ + **dict(__import__("os").environ), + "MICROCOSM_BATTERY_RECEIPT": str(rows_path), + }, + ) + summary = next( + ( + line.strip() + for line in reversed(completed.stdout.splitlines()) + if " passed" in line or " failed" in line or " error" in line + ), + "", + ) + if completed.returncode != 0: + print(completed.stdout[-4000:]) + raise SystemExit(f"battery failed: {summary}") + rows = [ + json.loads(line) + for line in rows_path.read_text(encoding="utf-8").splitlines() + if line.strip() + ] + + def verdict(row): + return ( + "ACCEPTED (both paths)" + if row["object_path"] is None and row["seal_path"] is None + else row["object_path"] + ) + + disagreements = [row for row in rows if row["object_path"] != row["seal_path"]] + tally = collections.Counter( + verdict(row) for row in rows if row not in disagreements + ) + document = { + "scope": ( + "diagnostic receipt of the discrimination battery; not a build, " + "certification or release artifact" + ), + "release_eligible": False, + "pytest_summary": summary, + "comparisons": len(rows), + "agreements": len(rows) - len(disagreements), + "disagreements": disagreements, + "unreachable_codes": UNREACHABLE, + "by_verdict": dict(tally.most_common()), + "rows": sorted(rows, key=lambda row: (row["test"], row["operand"])), + } + out.write_text(json.dumps(document, indent=2) + "\n") + print(summary) + print( + f"comparisons={document['comparisons']} agreements={document['agreements']} " + f"disagreements={len(disagreements)} codes={len(tally)}" + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/native-retention-seal/before_after_table.py b/experiments/native-retention-seal/before_after_table.py new file mode 100644 index 000000000..4f7dd032a --- /dev/null +++ b/experiments/native-retention-seal/before_after_table.py @@ -0,0 +1,98 @@ +"""Emit the before/after table from the three runs' own measurement JSONs. + +Reads the native-scale lane's committed baseline and after-run measurements and +this lane's, and prints the comparison the report quotes, so no figure in it is +transcribed by hand. + + python experiments/native-retention-seal/before_after_table.py +""" + +import json +import pathlib + +ROOT = pathlib.Path(__file__).resolve().parents[2] +RUNS = ( + ( + "baseline 5ff889814", + ROOT / "experiments/native-scale-transport/measurement-baseline-1-1000.json", + ), + ( + "transport after 5307249b3", + ROOT + / "experiments/native-scale-transport/measurement-after-1-1000-with-replay.json", + ), + ( + "retention seal (this lane)", + # The committed copy, which is byte-identical to the one the run wrote + # into its throwaway measurement worktree + # (~/PolicyEngine/_worktrees/microcosm-retention-after/.measure/after/ + # repeated-verification-measurement.json, sha256 acd55d7c1f462ffa...). + # Reading the committed copy keeps this table re-derivable after that + # worktree is removed. + ROOT + / "experiments/native-retention-seal/measurement-after-1-1000-with-replay.json", + ), +) +ROWS = ( + ("runner call CPU s", "runner", "call_cpu_seconds", 2), + ("runner call wall s", "runner", "call_wall_seconds", 2), + ("financial node loop wall s (19)", "runner", "node_loop_wall_seconds", 2), + ("prefix node loop wall s (9)", "runner", "prefix_node_wall_seconds", 2), + ( + "outside both node loops, wall s", + "runner", + "outside_both_node_loops_wall_seconds", + 2, + ), + # The replay row and the "vs after" column were quoted in the report while + # this generator produced neither, which an adversarial pass caught: the + # claim that no figure in the table is transcribed by hand was false of + # exactly those two. Both are derived here now. The baseline had no replay + # phase, so its cell is the same em dash a missing field gets. + ("required replay CPU s", "required_replay", "cpu_seconds", 2), + ("whole-process CPU s", "process", "cpu_seconds", 2), + ("whole-process peak RSS GB", "process", "peak_rss_bytes", None), +) +# The column the report leads its comparison with: this lane against the run it +# is trying to improve on, which is the transport lane's after-run. +DELTA = ("transport after 5307249b3", "retention seal (this lane)") + + +def main(): + loaded = [] + for label, path in RUNS: + try: + loaded.append((label, json.loads(path.read_text()), path)) + except FileNotFoundError: + loaded.append((label, None, path)) + print( + "| | " + + " | ".join(label for label, _, _ in loaded) + + f" | {DELTA[1].split(' (')[0]} vs after |" + ) + print("|---" * (len(loaded) + 2) + "|") + for name, section, key, places in ROWS: + cells, values = [], {} + for label, document, _ in loaded: + value = (document or {}).get(section, {}).get(key) + values[label] = value + if value is None: + cells.append("—") + elif places is None: + cells.append(f"{value / 1e9:.2f}") + else: + cells.append(f"{value:,.{places}f}") + before, after = values.get(DELTA[0]), values.get(DELTA[1]) + if before is None or after is None: + cells.append("—") + elif places is None: + cells.append(f"{(after - before) / 1e9:+.2f}") + else: + cells.append(f"{after - before:+,.{places}f}") + print(f"| {name} | " + " | ".join(cells) + " |") + for label, document, _ in loaded: + print(f"\n{label}: status={(document or {}).get('status')}") + + +if __name__ == "__main__": + main() diff --git a/experiments/native-retention-seal/dependent_test_battery.py b/experiments/native-retention-seal/dependent_test_battery.py new file mode 100644 index 000000000..799402fa1 --- /dev/null +++ b/experiments/native-retention-seal/dependent_test_battery.py @@ -0,0 +1,93 @@ +"""Run every test file that imports a module this lane touched, one per process. + +CI runs the build shard's groups in separate pytest processes precisely so that +one file's ``monkeypatch.setattr`` on a module-level function cannot trip +``survey_population_preparation._producer``'s live-code seal for every later +file -- the native-scale lane's report section 9a is the write-up of what +happens when they share one. This runs them the way CI does, with a bounded +number of processes at a time, and records each file's own summary line. + + python experiments/native-retention-seal/dependent_test_battery.py OUT.json [JOBS] +""" + +import concurrent.futures +import json +import pathlib +import subprocess +import sys +import time + +ROOT = pathlib.Path(__file__).resolve().parents[2] # the worktree root +PYTHON = ROOT / ".venv/bin/python" +FILES = sorted( + str(path.relative_to(ROOT)) + for path in (ROOT / "packages/microcosm-build/tests").glob("test_*.py") + if any( + marker in path.read_text(encoding="utf-8") + for marker in ( + "survey_population_replay", + "graph_atomic_survey_financial", + "graph_implementation", + ) + ) +) + + +def run(relative): + started = time.monotonic() + completed = subprocess.run( + [str(PYTHON), "-m", "pytest", relative, "-p", "no:randomly"], + cwd=ROOT, + capture_output=True, + text=True, + ) + tail = [line for line in completed.stdout.splitlines() if line.strip()] + summary = next( + ( + line + for line in reversed(tail) + if " passed" in line or " failed" in line or " error" in line + ), + "", + ) + return { + "file": relative, + "returncode": completed.returncode, + "summary": summary.strip(), + "wall_seconds": round(time.monotonic() - started, 1), + } + + +def main(): + out = pathlib.Path(sys.argv[1]) + jobs = int(sys.argv[2]) if len(sys.argv) > 2 else 4 + results = [] + with concurrent.futures.ThreadPoolExecutor(max_workers=jobs) as pool: + for result in pool.map(run, FILES): + results.append(result) + print( + f"{'ok ' if result['returncode'] == 0 else 'FAIL'} " + f"{result['file']} {result['summary']}", + flush=True, + ) + out.write_text( + json.dumps( + { + "scope": "diagnostic; not a build, certification or release artifact", + "release_eligible": False, + "invocation": "one pytest process per file, as CI runs them", + "files": len(results), + "failing_files": [r["file"] for r in results if r["returncode"] != 0], + "results": sorted(results, key=lambda r: r["file"]), + }, + indent=2, + ) + + "\n" + ) + print( + f"\nfiles={len(results)} failing={len([r for r in results if r['returncode']])}" + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/native-retention-seal/diagnostic-1-10-raises.json b/experiments/native-retention-seal/diagnostic-1-10-raises.json new file mode 100644 index 000000000..97394dacd --- /dev/null +++ b/experiments/native-retention-seal/diagnostic-1-10-raises.json @@ -0,0 +1,845 @@ +{ + "count": 208, + "tail": [ + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.ValueError", + "message": "list.remove(x): x not in list", + "file": "_py_warnings.py", + "function": "_add_filter", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.ValueError", + "message": "list.remove(x): x not in list", + "file": "_py_warnings.py", + "function": "_add_filter", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.ValueError", + "message": "list.remove(x): x not in list", + "file": "_py_warnings.py", + "function": "_add_filter", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.ValueError", + "message": "list.remove(x): x not in list", + "file": "_py_warnings.py", + "function": "_add_filter", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.ValueError", + "message": "list.remove(x): x not in list", + "file": "_py_warnings.py", + "function": "_add_filter", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.ValueError", + "message": "list.remove(x): x not in list", + "file": "_py_warnings.py", + "function": "_add_filter", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.IndexError", + "message": "string index out of range", + "file": "_parser.py", + "function": "Tokenizer.__next", + "wrapper": false + }, + { + "type": "builtins.IndexError", + "message": "list index out of range", + "file": "_parser.py", + "function": "SubPattern.__getitem__", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-diagnostic/.measure/diagnostic3/snapshots/preparation/header.json'", + "file": "", + "function": "exists", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-diagnostic/.measure/diagnostic3/snapshots/preparation'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-diagnostic/.measure/diagnostic3/graph-store/objects'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-diagnostic/.measure/diagnostic3/snapshots/preparation/header.json'", + "file": "", + "function": "exists", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-diagnostic/.measure/diagnostic3/snapshots/preparation'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-diagnostic/.measure/diagnostic3/graph-store/objects'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "builtins.IndexError", + "message": "string index out of range", + "file": "_parser.py", + "function": "Tokenizer.__next", + "wrapper": false + }, + { + "type": "builtins.IndexError", + "message": "list index out of range", + "file": "_parser.py", + "function": "SubPattern.__getitem__", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-diagnostic/.measure/diagnostic3/snapshots/preparation/header.json'", + "file": "", + "function": "exists", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-diagnostic/.measure/diagnostic3/snapshots/preparation'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-diagnostic/.measure/diagnostic3/graph-store/objects'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "microcosm.build.us_runtime.acs_person_coverage_authentication.ACSCoverageAuthenticationError", + "message": "CANONICAL_SIZE", + "file": "acs_person_coverage_authentication.py", + "function": "_require", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_person_coverage_authentication.ACSCoverageAuthenticationError", + "message": "CANONICAL_SIZE", + "file": "acs_person_coverage_authentication.py", + "function": "_json..charge", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_person_coverage_authentication.ACSCoverageAuthenticationError", + "message": "CANONICAL_SIZE", + "file": "acs_person_coverage_authentication.py", + "function": "_json..visit", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_person_coverage_authentication.ACSCoverageAuthenticationError", + "message": "CANONICAL_SIZE", + "file": "acs_person_coverage_authentication.py", + "function": "_json..visit", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_person_coverage_authentication.ACSCoverageAuthenticationError", + "message": "CANONICAL_SIZE", + "file": "acs_person_coverage_authentication.py", + "function": "_json", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_person_coverage_authentication.ACSCoverageAuthenticationError", + "message": "CANONICAL_SIZE", + "file": "acs_native_coverage_binding.py", + "function": "issue_acs_native_coverage", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError", + "message": "NATIVE_ISSUANCE_REFUSED", + "file": "acs_native_coverage_binding.py", + "function": "issue_acs_native_coverage", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError", + "message": "NATIVE_ISSUANCE_REFUSED", + "file": "survey_population_preparation.py", + "function": "prepare_authenticated_survey_population", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED: microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError: NATIVE_ISSUANCE_REFUSED", + "file": "survey_population_preparation.py", + "function": "prepare_authenticated_survey_population", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED: microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError: NATIVE_ISSUANCE_REFUSED", + "file": "graph_survey_population.py", + "function": "run_authenticated_survey_population", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED: microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError: NATIVE_ISSUANCE_REFUSED", + "file": "graph_atomic_survey_population.py", + "function": "run_atomic_survey_population", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED: microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError: NATIVE_ISSUANCE_REFUSED", + "file": "survey_population_preparation.py", + "function": "verification_epoch", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED: microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError: NATIVE_ISSUANCE_REFUSED", + "file": "contextlib.py", + "function": "_GeneratorContextManager.__exit__", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED: microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError: NATIVE_ISSUANCE_REFUSED", + "file": "graph_atomic_survey_financial.py", + "function": "run_atomic_survey_financial", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED: microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError: NATIVE_ISSUANCE_REFUSED", + "file": "survey_population_preparation.py", + "function": "verification_epoch", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED: microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError: NATIVE_ISSUANCE_REFUSED", + "file": "contextlib.py", + "function": "_GeneratorContextManager.__exit__", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED: microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError: NATIVE_ISSUANCE_REFUSED", + "file": "harness19_diag.py", + "function": "", + "wrapper": true + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-diagnostic/.measure/diagnostic3/snapshots/preparation/header.json'", + "file": "", + "function": "exists", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-diagnostic/.measure/diagnostic3/snapshots/preparation'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-diagnostic/.measure/diagnostic3/graph-store/objects'", + "file": "", + "function": "isdir", + "wrapper": false + } + ] +} \ No newline at end of file diff --git a/experiments/native-retention-seal/diagnostic-1-15-raises.json b/experiments/native-retention-seal/diagnostic-1-15-raises.json new file mode 100644 index 000000000..73fedc5b1 --- /dev/null +++ b/experiments/native-retention-seal/diagnostic-1-15-raises.json @@ -0,0 +1,845 @@ +{ + "count": 208, + "tail": [ + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.ValueError", + "message": "list.remove(x): x not in list", + "file": "_py_warnings.py", + "function": "_add_filter", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.ValueError", + "message": "list.remove(x): x not in list", + "file": "_py_warnings.py", + "function": "_add_filter", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.ValueError", + "message": "list.remove(x): x not in list", + "file": "_py_warnings.py", + "function": "_add_filter", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.ValueError", + "message": "list.remove(x): x not in list", + "file": "_py_warnings.py", + "function": "_add_filter", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.ValueError", + "message": "list.remove(x): x not in list", + "file": "_py_warnings.py", + "function": "_add_filter", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.ValueError", + "message": "list.remove(x): x not in list", + "file": "_py_warnings.py", + "function": "_add_filter", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.TypeError", + "message": "issubclass() arg 1 must be a class", + "file": "numerictypes.py", + "function": "issubclass_", + "wrapper": false + }, + { + "type": "builtins.IndexError", + "message": "string index out of range", + "file": "_parser.py", + "function": "Tokenizer.__next", + "wrapper": false + }, + { + "type": "builtins.IndexError", + "message": "list index out of range", + "file": "_parser.py", + "function": "SubPattern.__getitem__", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth/.measure/fifteenth-diag/snapshots/preparation/header.json'", + "file": "", + "function": "exists", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth/.measure/fifteenth-diag/snapshots/preparation'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth/.measure/fifteenth-diag/graph-store/objects'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth/.measure/fifteenth-diag/snapshots/preparation/header.json'", + "file": "", + "function": "exists", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth/.measure/fifteenth-diag/snapshots/preparation'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth/.measure/fifteenth-diag/graph-store/objects'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth/.measure/fifteenth-diag/snapshots/preparation/header.json'", + "file": "", + "function": "exists", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth/.measure/fifteenth-diag/snapshots/preparation'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth/.measure/fifteenth-diag/graph-store/objects'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "builtins.IndexError", + "message": "string index out of range", + "file": "_parser.py", + "function": "Tokenizer.__next", + "wrapper": false + }, + { + "type": "builtins.IndexError", + "message": "list index out of range", + "file": "_parser.py", + "function": "SubPattern.__getitem__", + "wrapper": false + }, + { + "type": "microcosm.build.us_runtime.acs_person_coverage_authentication.ACSCoverageAuthenticationError", + "message": "CANONICAL_SIZE", + "file": "acs_person_coverage_authentication.py", + "function": "_require", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_person_coverage_authentication.ACSCoverageAuthenticationError", + "message": "CANONICAL_SIZE", + "file": "acs_person_coverage_authentication.py", + "function": "_json..charge", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_person_coverage_authentication.ACSCoverageAuthenticationError", + "message": "CANONICAL_SIZE", + "file": "acs_person_coverage_authentication.py", + "function": "_json..visit", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_person_coverage_authentication.ACSCoverageAuthenticationError", + "message": "CANONICAL_SIZE", + "file": "acs_person_coverage_authentication.py", + "function": "_json..visit", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_person_coverage_authentication.ACSCoverageAuthenticationError", + "message": "CANONICAL_SIZE", + "file": "acs_person_coverage_authentication.py", + "function": "_json", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_person_coverage_authentication.ACSCoverageAuthenticationError", + "message": "CANONICAL_SIZE", + "file": "acs_native_coverage_binding.py", + "function": "issue_acs_native_coverage", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError", + "message": "NATIVE_ISSUANCE_REFUSED", + "file": "acs_native_coverage_binding.py", + "function": "issue_acs_native_coverage", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.acs_native_coverage_binding.ACSNativeCoverageBindingError", + "message": "NATIVE_ISSUANCE_REFUSED", + "file": "survey_population_preparation.py", + "function": "prepare_authenticated_survey_population", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED", + "file": "survey_population_preparation.py", + "function": "prepare_authenticated_survey_population", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED", + "file": "graph_survey_population.py", + "function": "run_authenticated_survey_population", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED", + "file": "graph_atomic_survey_population.py", + "function": "run_atomic_survey_population", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED", + "file": "survey_population_preparation.py", + "function": "verification_epoch", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED", + "file": "contextlib.py", + "function": "_GeneratorContextManager.__exit__", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED", + "file": "graph_atomic_survey_financial.py", + "function": "run_atomic_survey_financial", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED", + "file": "survey_population_preparation.py", + "function": "verification_epoch", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED", + "file": "contextlib.py", + "function": "_GeneratorContextManager.__exit__", + "wrapper": true + }, + { + "type": "microcosm.build.us_runtime.survey_population_preparation.SurveyPopulationPreparationError", + "message": "PREPARATION_ISSUANCE_REFUSED", + "file": "harness19_diag_fifteenth.py", + "function": "", + "wrapper": true + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth/.measure/fifteenth-diag/snapshots/preparation/header.json'", + "file": "", + "function": "exists", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth/.measure/fifteenth-diag/snapshots/preparation'", + "file": "", + "function": "isdir", + "wrapper": false + }, + { + "type": "builtins.FileNotFoundError", + "message": "[Errno 2] No such file or directory: '/Users/maxghenis/PolicyEngine/_worktrees/microcosm-retention-fifteenth/.measure/fifteenth-diag/graph-store/objects'", + "file": "", + "function": "isdir", + "wrapper": false + } + ] +} \ No newline at end of file diff --git a/experiments/native-retention-seal/harness19_diag.py b/experiments/native-retention-seal/harness19_diag.py new file mode 100644 index 000000000..6f85043b1 --- /dev/null +++ b/experiments/native-retention-seal/harness19_diag.py @@ -0,0 +1,721 @@ +"""The native-scale lane's 1/10 run: above the transport ceiling that was. + +Identical to the lane's baseline harness except for the sample, the ceilings and +one addition. The sample is 1/10 -- 158,737 of the 1,587,376 source households, +where the single bounded encode refused at 96,860 -- so it runs against its own +source tree, whose ``selection-request.json`` carries ``fraction: [1,10]`` +because the staged pilot request pins 1/1000 and ``_request`` requires the +argument to match it. Every other source file in that tree is an APFS clone of +the staged original and hashes identically; the recovered originals are not +written, linked or moved. + +The addition: every flush captures the roster transport's own on-disk receipt +(``snapshots/preparation/header.json``) and the allocation receipt from the +manifest if one exists yet. The ceiling question is answered by the preparation +and allocation nodes, which run in the first minutes, so a run the CPU ceiling +truncates still carries the evidence for it. + +Original docstring follows. + +Baseline for the native-scale lane: the 19-node graph, uncapped by node. + +This is ``harness19_verify_once.py`` from the verify-once lane with four +additions and no change to what is measured -- same call, same arguments, same +sample, same seed, same sampler, same interval, same refusals: + +* the ceilings are the native-scale brief's (9,000 CPU-s, 48 GiB, 12,000 wall-s) + rather than the verify-once lane's, so no node is cut short; +* a current-resident-size series is sampled every second through ``libproc``'s + ``proc_pidinfo``, because ``ru_maxrss`` is a high-water mark and a retention + slope needs the trace, not the peak; +* the ``run_atomic_survey_financial`` call is timed on its own, so the runner + time outside the node loop is a subtraction between measured quantities + rather than an inference; +* the returned manifest's per-node ``wall_time_s`` is recorded, which is what + the subtraction subtracts. + +Nothing is wrapped: the runtime still refuses instrumented producers, so +attribution is still the stack sampler's. + +Original docstring follows. + +Nineteen-node measurement for the verify-once lane, on this branch only. + +The instrumentation is ``probe_verify_once.py`` unchanged -- the same stack +sampler at the same interval, the same ceilings, the same refusals, the same +output shape. The only difference is the call: this runs the base financial +graph with the exact arguments the accepted v4 cold pilot ran +(``~/PolicyEngine/_recovered/pilot-runs/native19-v2/run/test_native_nineteen_node_financial.py``: +fraction 1/1000, seed 20260908, geography seed 20260908, +``demographic_conditioning=True``, ``n_estimators=2``, ``resume="auto"``), so +its wall, CPU and peak RSS are comparable with that receipt's +5,362.05 s / 5,278.61 s / 8.67 GiB. + +Two differences from that receipt are known and are not this change: it ran on +source snapshot ``2ca11c85a``, and its ``person-income-attachment.h5`` was the +pre-restoration ``5996dcdd...`` rather than the staged ``9ebc0ef2...``. Both +files are exactly 666,333,922 B, so the bytes the source tree hashes are the +same volume either way. + +Original docstring follows. + +Before/after measurement for the verify-once lane: the nine-node prefix. + +A parameterised copy of the v5 pilot probe +(``~/PolicyEngine/_recovered/pilot-runs/native45-v5/probe_repeated_verification.py``). +Everything that decides *what is measured* is verbatim: the same nine-node +population prefix, the same 1/1000 sample, the same seed, the same stack +sampler at the same interval, the same ceilings, the same output shape. The +only changes are the ones a before/after comparison needs: + +* the source tree, the staged run inputs and the output directory come from + the environment, so the identical file measures both trees; +* every imported ``microcosm`` module is asserted to live under that tree, + so a stray editable install cannot silently measure the wrong source; +* a resident-memory ceiling is enforced alongside the CPU ceiling; +* the load average and the interpreter's third-party versions are recorded + with each run, because this machine carries other lanes' work. + +Sources are read by path and never written. Nothing here is a build, a +certification or a release artifact. + + MEASURE_BASE= MEASURE_RUN= \ + MEASURE_PROBE= MEASURE_LABEL=