Update idna requirement from >=3.15 to >=3.18#323
Closed
dependabot[bot] wants to merge 2 commits into
Closed
Conversation
dependabot
Bot
added
dependencies
dependabot
Bot
added
dependencies
Updates the requirements on [idna](https://github.com/kjd/idna) to permit the latest version. - [Release notes](https://github.com/kjd/idna/releases) - [Changelog](https://github.com/kjd/idna/blob/master/HISTORY.md) - [Commits](kjd/idna@v3.15...v3.18) --- updated-dependencies: - dependency-name: idna dependency-version: '3.18' dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>
dependabot
Bot
force-pushed
the
dependabot/pip/idna-gte-3.18
branch
from
June 27, 2026 18:33
08b1fc4 to
3e705a3
Compare
ciaranra
added a commit
that referenced
this pull request
Jul 6, 2026
ciaranra
added a commit
that referenced
this pull request
Jul 7, 2026
* Align Guppy DEM reference normalization * Fix re-review ordering gap: resolve the QASM program before the neo rejections so a sourceless .classical()+neo reports the missing source, not the classical-override rejection * Report DEM diagnostic progress and partial results * Add surface sweep JSON comparison tool * Improve graphlike surface decoder validation * Make DEM diagnostics resumable from saved results * Add surface check plan metadata * Support MeasureFree in sim_neo extract_commands and align stale measurement-count tests to the circuit's num_measurements * Normalize the fresh traced circuit in the constrained-budget cache test to match the native DEM path * Restore QEC branch health checks * Thread check plan metadata through topology cache * Clean decoder study report whitespace * Make QSystem platform explicit and selectable in HUGR-QIS compilation (default Helios) * Apply rustfmt to QSystem platform threading * Make the automatic Clifford-angle rotation step defer to user-registered GateDefinitions decompositions (gate on has_decomposition in both dispatch chains) so explicit decompositions are not silently bypassed at Clifford angles * Bump pyo3 to 0.29 to fix RUSTSEC-2026-0176 and RUSTSEC-2026-0177 * Narrow the Sampling::SubsetSimulation variant doc to match the function/module accuracy caveat (the multi-level estimator biases upward; deep-rare-event estimates are approximate), per Codex review of the remaining-work doc * Harden parser/binding robustness: SparseDem rejects malformed D/L tokens like the other parsers, and the two algorithm-decoder bindings return PyErr instead of panicking on empty segments or missing boundary-gate fields * Address residual review nits: reject boundary-gate observable bits >=64 in the descriptor bindings (+ debug_assert and obs_bits helper at the apply site), and correct the predecoder zero-alloc docstring * Guard subset_simulation against silently returning a biased estimate: default to a single unbiased level and require explicit .allow_biased_multilevel() to engage the (biased) multi-level path, fail-fast at build otherwise; mirrored in the Python binding * Fix inverted threshold selection in ProperSubsetSimulation/QecSubsetSimulation: descending-sorted scores must take the survivor threshold at index p0*n (keep top p0), not (1-p0)*n (which kept the bottom and made each level's conditional ~1-p0 instead of ~p0); add a discriminating threshold test plus the previously-missing analytical-unbiasedness guard for the multi-level path * Make the 64-observable mask limit consistently fail-loud: sampler errors on >64 observables (observable_dem_output_mask returns Result) instead of silently dropping ids >=64, and the per-shot truth-mask helper takes the validated mask * Complete the coefficient-of-variation for the structurally-correct ProperSubsetSimulation/QecSubsetSimulation: include the previously-omitted final failure-fraction term (Codex round-3 finding), via a shared independent_levels_cv_squared helper that documents the remaining inter-level-correlation approximation as an optimistic lower bound; validate the reported CV against the empirical spread across 200 runs (lower-bound ~1.8x below empirical, final term proven included) * Lock the engines depolarizing-vs-GNM measurement-physics distinction (the B1 root cause) on both sides: add a GNM meas-twice equivalence cell pinning the record-flip convention (second measure = p) to complement the existing depolarizing state-flip cell (2p(1-p)), both cross-stack analytic-pinned so a GNM->state-flip mismapping fails * Make the special.rs assert_close test helper enforce its stated RELATIVE tolerance: drop the OR'd absolute fallback that silently weakened it to an absolute check for |expected| < 1 (a claimed 1e-12 relative became 1e-12 absolute, ~1000x looser at small values); all 17 numerics tests still pass under the strict check, so the validation-gate numerics genuinely meet their stated accuracy * Lock the realistic-nonzero-defaults trap in G4: test that PerGateTypeNoise::from_base_noise(NoiseConfig::default()).to_neo_channel() does not trip the idle guard and carries the 0.01 base/meas/init rates bit-identically to the hand-built neo channel (a dropped or rescaled default would diverge), the exact 0.01-everywhere case the GNM/qec mappings mishandled before * Knock out two cosmetics: bump the new pecos-results crate's moved-code headers to 2026 (matching the project new-files convention and the sibling shim), and give the two stacks independent seeds in the cross-stack STATISTICAL comparisons (matrix + routing depolarizing) so agreement comes from matching conventions, not a shared RNG stream that would make the check tautological if streams ever converged; deterministic same-seed bit-identical tests left unchanged * Handle Selene runtime capacity after merged runtime changes. * Add logical decoder descriptor validation regressions. * Fix subset CV double-count: compute coefficient of variation from committed product factors only, not terminal recorded-but-uncommitted levels * Respect explicit QIS physical qubit capacity. * Support constrained SZZ surface memory circuits. * Thread check plans through Guppy surface generation * Phase 1 step 1: add ObsMask, an inline-optimized observable flip mask (one stack word for <=64 observables, spills to heap beyond) lifting the u64 observable cap * Require check plans to match current surface renderers * Phase 1 step 2: add ObservableDecoder::decode_obs (wide ObsMask, default-bridges the u64 fast path) and give LogicalSubgraphDecoder a real wide implementation; its u64 path now narrows and errors on >64 instead of truncating * Accept check plans in direct surface builders * Phase 1 step 2c-1: widen the LogicalSubgraphDecoder batch decode-count path to ObsMask (decode_count_batched + SampleBatch.extract_obs_mask_wide), preserving identical <=64 behavior * Phase 1 step 2c-2: support >64 observables on the LogicalSubgraphDecoder decode path -- remove the shared >64 construction reject, make the u64/parallel/windowed paths fail loud (not truncate), and add a 65-observable wide decode+count test * Phase 1 step 2c-3: LogicalSubgraphDecoder.decode/decode_batch return arbitrary-precision Python ints (ObsMask->int) so >64 observables are visible from Python with no truncation; add wide-observable Python tests * Fix engines angle-dependent two-qubit noise to read the signed principal angle and add GeneralNoiseModelBuilder::pauli_with_angle_scaling for cross-stack translation * Add boundary-first SZZ surface check plan * Translate engines GeneralNoiseModel angle-dependent two-qubit noise to the neo stack in sim().stack(Neo) * Use trace-friendly backend for Guppy operation capture * Add V6 cross-stack example-circuit sweep covering 3-qubit, whole-register-measure, and deterministic facade circuits * Test trace-friendly Guppy operation capture * Reject HUGR on the neo stack until its result contract matches the engines named-register format * Map BiasedDepolarizingNoise to the neo stack with record-flip asymmetric measurement * Bring zlup, guppy-zlup, and zluppy crates onto dev and fix AST/Ord/pyo3 drift so all three build * Document the full neo-translated noise surface on SimStack::Neo * Route HUGR through the PHIR engine on the neo stack so its results use the named-register contract * Add uniform Clifford frame SZZ DEM plumbing * Support traced SZZ Clifford-frame surface programs * Reject control-flow HUGR in the PHIR converter and guard against empty neo results * Add neo determinism and worker-count-invariance regression tests * Make cross-stack engines baselines explicit so they stay meaningful after the default flip * Make neo single-qubit emission gate-removing to match engines (apply the gate dagger) * Make neo two-qubit emission gate-removing and generalize the gate dagger to 2q gates * Phase 1 step 2c-5a: widen WindowedLogicalSubgraphDecoder to ObsMask (decode_obs override, u64 path narrows + errors on >64), removing the interim >64 hard reject * Add pecos-phir-pliron: validated Bell port proving build-PHIR-on-pliron end-to-end (round-2 gate) * Phase 1 step 2c-5b: widen the LogicalCircuit/LogicalAlgorithm decode path to ObsMask (DecodeStrategy::decode_obs + FullCircuit/Windowed strategy overrides + decoder decode_obs overrides), removing the last core >64 reject; u64 paths narrow and fail loud * Commit Cargo.lock smallvec entry for pecos-decoder-core (lockfile was left inconsistent with the Cargo.toml dep added in 45b612b) * Map GeneralNoiseModel emission ratios through the sim().stack(Neo) facade now that neo emission is gate-removing * Apply rustfmt to the ObsMask/wide-decode changes and pre-existing re-export drift; just fmt clean * Fix clippy cast_possible_wrap in the >64-observable sampler test (i64::try_from instead of as i64) * Apply black formatting + ruff E741 rename across touched Python files (pre-merge lint pass) * pecos-phir-pliron M4: adaptive multi-batch measurement-conditioned control through real HybridEngine * Complete >64 observable support across all Python decoder entry points (LogicalCircuit/Algorithm/Windowed decode big-ints + wide decode_count), widen the pecos-qec sampler truth path and SampleBatch big-int constructor (ObsMask BitAndAssign + py_to_obsmask), fix example-script ruff nits * pecos-phir-pliron M5+M6: region-based qec.if + literal qprog.ll port (rotations + CFG-lift) via real HybridEngine * Flatten the circuit once in reliable_observables instead of per-observable (helpers take the already-flattened circuit) * Extract the shared Monte Carlo sampling vocabulary into pecos-engines and un-deprecate neo's .shots() shortcut * Split .shots(n) from an argless fail-fast .run() and add .sampling(monte_carlo()) to the facade * Phase 1: pecos-phir-pliron M7 -- library, explicit measurement-SSA/export mapping, branch-taken fixture, negative tests * Phase 1: pecos-phir-pliron measurement-SSA registry -- side-table metadata, lightweight measure ops * Add .shots(n) and an argless .run() to the Python sim() facade * Phase 1: pecos-phir-pliron differential vs pecos-phir + measure-in-branch coverage * Wrap over-long sim_neo() chains in qec/analysis.py to fix E501 * pecos-phir-pliron: Bell via qec.record export + region-scope record verifier (round-5 increment) * pecos-phir-pliron: native Angle64 fixed-point angle attr + cond_x i1 verifier * Reject non-unit emission_scale in the neo facade subset and make facade worker setters last-writer-wins * Migrate the Rust doc-test snippets to the argless .shots(n).run() facade API * pecos-phir-pliron: add non-i1 cond_x verifier negative test (round-6) * pecos-phir-pliron: promote exp -> crates, depend on crates.io pliron 0.15 (strangler first step) * Support checkerboard Clifford surface frames * pecos-phir-pliron: add opt-in from_qis_llvm_ir_pliron adapter + real call-path test * pecos-phir-pliron: tighten rz/rx/ry/if verifiers + registry/IR-drift assertion (cutover items 1-2) * pecos-phir-pliron: dynamic qubit count + 3-qubit GHZ fixture (cutover items 3,5) * Cover both checkerboard surface frame orientations * pecos-phir-pliron: parse -> Result, reject out-of-subset input with structured errors (final cutover item) * pecos-phir-pliron: adopt CFG-shape classifier + add branch-condition dataflow validation (round-7) * pecos-phir-pliron: widen gates (cz/swap/x) + shared gate_op_to_cmd helper (fix walker drift) * Add balanced surface ancilla scheduling * Forward-flow SZZ Guppy data frames within helpers * Add optional SZZ runtime barriers * Add selective SZZ runtime barrier policy * Fix zlup composite-gate tests to canonical cx (q0, q1) syntax and reject duplicate gate declarations * Gate zlup cli integration tests behind the cli feature so they skip without the binary * Fix QIS LLVM qubit allocation by not freezing an unstarted dynamic engine's inferred-zero count as a hard Selene hint * Tighten zlup gate registration: reject mismatched built-in shadowing and declare-then-define, allow exact-signature built-in redeclaration * Run zlup cli-feature integration tests in the rust gate (skipped by the default-feature workspace run) * Unify the workspace on selene-core 0.2.2 by bumping pecos-selene-core and the python selene plugin crates to match pecos-qis * Scope the QIS persistent compiled-program cache to the running build so a stale shared object is never reused across builds with a different ABI * Model zlup gate origin (Builtin/TargetDeclared/CompositeDefined) for per-origin redeclaration rules and clearer diagnostics * Harden the QIS program cache: stable SHA-256 key (replacing the unstable DefaultHasher) plus an auditable per-object manifest sidecar * Make the legacy u64 SampleBatch observable APIs fail loud on >64 observables (reject wide batches up front) and add a wide get_observable_mask_wide getter * Make apply_boundary_gate fail loud on observable bits >= 64 (real Result check, not debug_assert) so direct Rust callers cannot silently shift-overflow the u64 frame * Strengthen the QIS cache key with explicit ABI inputs: a stable ProgramFormat cache tag (not Debug), crate version, and target triple * Distinguish an explicit .qubits(0) (forwarded as a hint) from a dynamic engine's inferred unknown-0 (not frozen) in SimBuilder * Add generic trace metadata plumbing for QIS replay * Add SZZ source metadata plumbing * Preserve qubit-scoped SZZ trace metadata * Fence SZZ prefixes before runtime barriers * Document Guppy barrier trace gap * Add hosted operation design note * Add hosted SZZ metadata keys * Guard the narrow u64 decode APIs on DEM/decoder observable width (not just batch truth-width): reject >64-observable DEMs up front, fixing the decode_count_batch 1<<j overflow and the all-zero-truth bypass; guard decode_each too * Add hosted operation metadata validation * Widen the SampleBatch decode methods to wide ObsMask masks (inline-fast for <=64, correct for >64) instead of rejecting >64: no truncation/panic, decode_count_batch decodes >64, decode_each returns Python ints * Add strict hosted trace validation plumbing * Add hosted SZZ barrier handoff target * Invert the ObservableDecoder trait: decode_obs (wide ObsMask) is now the required primitive, decode_to_observables (u64) a derived default that errors on >64. Every inner decoder packs observables wide (PyMatching/DEM directly, matching decoders via from_u64), so the generic SampleBatch decode path fully handles >64 with no panic/truncation * Fail fast when the default (non-growing) SparseStab quantum engine would be built with an inferred-zero qubit count from a dynamic classical engine, instead of constructing a 0-qubit engine that panics on first allocation * Strengthen the QIS cache key further: use the real build target triple (build-script TARGET, distinguishes gnu/musl) and fold the runtime-selected QIS FFI + Selene shim identity (path + mtime, incl. PECOS_SELENE_SHIM_PATH override) into the digest * Revert the inferred-zero default-quantum fail-fast: it broke the QASM sim path (QASMEngine reports 0 qubits + default quantum, which works fine because SparseStab grows on allocation). The path is benign, already covered by pecos-qasm expression_separation_test * Add runtime barrier helper for SZZ traces * Fail loud (not overflow-panic) when a graphlike matching decoder is built on a >64-observable DEM: add DemMatchingGraph/DemCheckMatrix ensure_observables_fit_u64 guards at every matching-decoder construction site, directing >64 cases to pymatching or LogicalSubgraphDecoder (round-4 Finding A) * Fix the inferred-zero default-quantum panic properly via a ClassicalEngine::has_dynamic_qubit_count capability: reject only dynamic-unknown-zero (QisEngine) + default fixed-size quantum, leaving genuinely-0-qubit static engines (classical-only QASM) untouched (round-4 Finding D) * Pin the selected QIS FFI + selene shim library paths once (OnceLock) and route both the cache-key digest and the dlopen singletons through them, so the hashed library identity always matches the loaded one even if PECOS_SELENE_SHIM_PATH/search state changes mid-process (round-4 Finding C) * Reject ambiguous hosted operation metadata * Make PyMatching's narrow decode_batch_to_observables u64 batch API fail loud on >64 observables (8+ bit-packed bytes) instead of silently overflowing the shift; wide callers use decode_obs (round-4 minor) * Apply rustfmt to the slr-polish-inherited crates (zlup, guppy-zlup, zluppy, pecos-phir-pliron) so cargo fmt --all --check is clean * Forward has_dynamic_qubit_count through Box<dyn ClassicalControlEngine> (round-4 Finding-D guard was inert because the boxed engine masked QisEngine's override) and mark PhirEngine dynamic too (round-5 Finding B) * Guard the remaining unguarded >64-observable matching-decoder construction paths: FusionBlossom add_edge/add_boundary_edge (covers from_check_matrix + manual builder) and make UfDecoder::from_matching_graph return Result instead of overflow-panicking (round-5 Finding A) * Route the remaining raw library-discovery bypasses (Windows DLL search dirs + JIT import lib, public get_qis_ffi_lib_path) through the pinned paths so they match the cache-key/loaded identity (round-5 Finding C) * Scope SZZ hosted metadata by counted round * Use physical SZZ hosted prefixes in Guppy * Allow SZZ Guppy builds without trace metadata * Use two-qubit runtime barrier for SZZ hosted prefixes * Use native Selene runtime barriers * WIP: add pecos-phir dynamic-zero guard test + wide-observables matching-decoder qec tests * Pack generated SZZ trace metadata * Route pecos-cli CUDA Python install through cuda_python_group() after dev split the cuda extra into cuda12/cuda13 * Reconcile CI LLVM cache config to 21.1 in pr-core-gate + python workflows (round-6 Finding B) * Build the dependency-free [all] extra in pecos python build and fix the misleading CUDA message (round-6 Finding D) * Make explicit --cuda build pecos-rslib-cuda (auto-detect informs only) so the build and message are accurate (round-7 Finding B) * Check the cuda12/cuda13 split in check_python_workspace's CUDA extra/group invariant (round-7 Finding D) * Require both cuda12/cuda13 extra+group in check_python_workspace, rejecting deletion not just mismatch (round-8 Finding B) * Normalize quoted __hugr__ helper symbols so function-local SZZ trace/runtime-barrier declarations lower to public FFI symbols * Normalize PECOS helper symbols at the LLVM module level so both text IR and bitcode export the public ABI symbols (round-10 Finding B) * Merge duplicate PECOS helper declarations to one public ABI symbol instead of an LLVM-suffixed name (round-11 Finding B) * Reject conflicting PECOS helper signatures instead of silently merging into an ABI-mismatched symbol (round-12 Finding B) * Validate PECOS helper declarations against the fixed pecos-qis-ffi ABI, rejecting any wrong signature (round-13 Finding B) * Clarify the generic-barrier xfail reason: name the supported SZZ runtime-barrier path and why it stays strict * Apply ruff/black formatting and fix ruff lint across never-linted SZZ/zlup/examples code * Fix all clippy -D warnings across the workspace and apply rustfmt * Resolve dependency-integrity: allowlist new unsafe roots, add vscode npm lock, refresh fuzz lock * Bump wasmtime from 45 to 46 * Bump rustworkx-core from 0.17 to 0.18 * Remove unused itertools workspace dependency * Adopt guppylang 0.21.16 with binary HUGR serialization and round-scoped generated Guppy modules * Add pecos.guppy.variant_scoped to name-scope parameterized Guppy programs, fixing the cross-num_rounds Selene build-cache collision in the selene-parity tests * Fix dependency advisories in the uv/cargo locks (restoring dev's jupyter-chain bumps lost in the merge relock, re-locking zlup/zluppy with a corrected zluppy path dep, bumping anyhow) and add per-directory OSV-scanner ignore configs * Update optional-dependency tests for binary HUGR envelopes and LLVM 21 opaque-pointer QIR, fixing the vacuously-passing mz/read_result pairing check * Delete the stale tests/slr tree, superseded by slr_tests * Fix guppy constant rotation angles silently executing as zero-angle gates by tracing the static angle extraction through guppy's 1-tuple wrap, with a Rust regression test and the real-quantum-circuits tests rewritten to the actual result contract * Strengthen the tier2 mz/read_result tripwire to count-check both regex halves and correct the measurements-ordering comments to the actual qubit-id-order contract * Fail loud on unresolvable rotation angles instead of silently emitting zero-angle gates, fixing the runtime angle chain (tuple-valued constants, prelude classical-op port counts, static fallback for expression angles) with fixture-backed engine regression tests * Add a regression test pinning the measurements rows' qubit-id ordering * Fold in Codex round-2 findings: pin the runtime tuple angle chain with wire-state assertions, replace vacuous measurements lookups with hard indexing across the guppy tests, and xfail the two array+loop programs whose pre-existing silent result truncation the de-vacuumed assertions exposed * De-vacuum the seeded-reproducibility test that round 3 flagged (hard indexing plus shot-count assert before comparing runs) * Remove dead measurement_N fallback branches from the guppy tests (the keys never exist for plain-measure programs) * Fix classical value flow through HUGR control flow: first-class Sum values with executing Tag nodes, payload propagation across block/case/exit boundaries, unified classical-op classification, extension-aware readiness gating, per-iteration re-execution resets, and defer-instead-of-fabricate tuple/conversion/load_nat handlers, with a ch-gate end-to-end regression test * Give the optional-dependency test lane a post-merge CI home and drop the stale zero-test pecos-rslib line from pytest-dep * Make result capture and tket.bool handlers defer on missing or non-bool inputs instead of fabricating values or silently dropping results * Fix the loop-iteration freeze: clear processed flags for all op categories before any readiness check during CFG block re-activation, so Calls re-fire with fresh arguments instead of re-running iteration 0 forever * Route empty-block CFG transitions through the canonical two-phase transition path, deleting the hand-rolled activation copy that skipped stale-value clearing and checked Call readiness against uncleared producer flags * TailLoop parity with the CFG re-activation fix: queue body LoadConstants on expansion and re-entry, and clear stale body wire values after continue-value propagation * Land completion-time stall detection: queue drain with active control flow or starved deferred nodes now returns a descriptive error instead of silently truncated results, and the conditional_x test pins the fail-loud contract for the unsupported nested-TailLoop shape it exercises * Track nested Call/TailLoop/Conditional nodes in case completion with the two-phase clear-then-queue discipline, guard case completion on active nested containers, and run the completion hooks on the pending-conditional resolution path * Implement proper collections.borrow_arr semantics (sized all-borrowed arrays with Borrowed hole tracking, is_borrowed support, defer-on-missing inputs), add iu_to_s/is_to_u arms, and gate first TailLoop expansion on input readiness * Close the second silent-completion path (stall check on the pre-drain empty-queue return, plus pending TailLoop controls in the report) and clear outer container gates for TailLoop body ops at expansion so retried nodes are not permanently starved * Clear all container gates for case ops at conditional expansion so retried case-internal nodes inside loops are reachable by queue_ready_successors * Complete guppy array-indexing support: propagate TailLoop continue-state from executed Sum values, resolve forwarded generic type args through the active call chain, and un-xfail test_discard_array now that borrow-array programs run end-to-end * Re-propagate active case inputs when measurement results arrive, fixing short-circuit boolean programs whose case expands before a later measurement's value exists * Add debug logging for successor queueing decisions (neighbours and skip reasons) to make defer-starvation diagnosis tractable * Execute Tags over linear payloads as classical ops with QubitRef fallback and qubit-wire mapping on Sum-payload propagation, resolve generic new_all_borrowed sizes through the call chain, retry pending TailLoop controls on case completion, and stop replaying superseded block transitions over fresh loop-iteration inputs * Scope quantum-op collection to immediate containers (no premature unselected-case gate execution), clear descendant wire values on function re-call, reset case quantum ops at re-expansion, guard TailLoop body completion on active cases, and implement borrow_arr.get * Fix double conditional expansion across the queue and pending paths, defer gates whose qubit producer is still pending (implicit qubits only for processed or Input sources, keyed to the source wire), and clear qubit-wire mappings alongside classical values at every re-activation site * Prefer a qubit mapping on the Input port itself before tracing through it, so Sum-payload QubitRefs on case Inputs resolve instead of falling through to outer unmapped wires * Mirror QubitRef outputs of classical and prelude tuple ops into the qubit-wire map, and clear a Call node's own output wires at re-activation * Clear stale output wires for every case op category at expansion (a measurement queued in the same expansion resolved the previous iteration's unpacked qubit), completing guppy measure_array support and un-xfailing the last array test * Fold in Codex round-3 findings: stop call/bool collection at case boundaries, clear case Input ports before propagation, propagate executed Sum payloads on TailLoop break and CFG exit regardless of source shape, and defer instead of fabricate in collections.array get/set/new_array and futures.Read * Reject direct recursion with a clear error, make the structural Tag branch fallback return the tag (consistent with the value path), and replace the silent payload-offset reset with a loud warning * Rewrite the classical executor with typed extraction (present-but-unconvertible inputs defer instead of computing on fabricated defaults) and honor classified signedness for division, modulo, ordering comparisons, and right shift * Model sum_with_error outputs for checked division, checked modulo, and float truncation instead of collapsing them to raw scalars that consumers misread as tags * Implement borrow_arr pop_left, discard_empty, and new_array, flipping the conditional_x fixture test from a fail-loud stall pin to a clean end-to-end completion test * Fold in Codex round-4 findings: Euclidean signed division/modulo per the HUGR spec, strict checked-truncation bounds, UInt-aware unsigned extraction and convert_u signedness, pop_left defers on borrowed holes, delete the Conditional control-value branch shortcut, and pin conditional_x gate counts * Convert unconditional eprintln debug spam to log-gated debug and pin Euclidean division semantics with an end-to-end guppy test * Deep-review handler contract sweep: defer-not-fabricate across arithmetic/array/qsystem/futures/random handlers, spec-shape array ops (option and either Sums), delete shadowed divergent arms, rotate-mod-width, inarrow error-Sums, borrow_arr clone and to_array, unknown ops defer loudly, and re-pin conditional_x at the newly-exposed higher-order scan gap * Complete no-CFG passthrough calls properly and error on non-passthrough plain bodies, defer unparseable LoadConstants (rotation constants now parse), and run case-completion hooks after Call and TailLoop completion * Raise fatal execution faults instead of silent fallbacks: out-of-range branch tags error via a poison field, executed prelude.panic is a hard error, ishr is logical per spec, TailLoops get an iteration ceiling, sparse successor lists truncate loudly instead of shifting tags, pending resolvers early-return before cloning the HUGR, and first TailLoop expansion gets the two-phase state-clearing discipline * De-vacuum the test corpus: value-anchor the truthy-list and len-only assertions, require zero shot failures in the statevec tests, fail tests on pipeline errors instead of success-gating (exposing ten dead tests now strict-xfailed with precise reasons including seven never-compiling programs), add a real for-loop test, enable the years-disabled X-branch assertion, and add deterministic shift/zero-iteration/div-zero/recursion tests * Wrap the strict-xfail reason strings to the line-length limit * Fold in round-6 re-review: RNG ops emit value-first with NewRNGContext returning an option per the tket-qsystem signatures, RandomAdvance defers on missing context, the empty-block multi-successor path errors on out-of-range tags, unwired no-CFG passthrough outputs error, CFG cycles get a transition ceiling, and division by zero panics per the spec (test flipped from the legacy pin) * Fix nested-loop starvation (zero-op conditional cases now run completion hooks that wake order-edge consumers), add a 14-program dynamic semantic sweep, and fold in Codex round-7: RNG ops emit value-first tuples and NewRNGContext a real option (pinned by a builder-chain unit test), RandomInt masks to 32 bits, RandomIntBounded poisons on non-positive bounds, futures.Free defers instead of silently succeeding, and zero-output no-CFG function bodies are shape-checked instead of vacuously passing * Replace the boolean handler contract with a typed HandlerOutcome/ClassicalOutcome enum (Processed/Defer/Fault), making poison faults first-class handler return values * Consolidate the six container-activation sites (CFG entry/transition, case expansion, TailLoop expand/continue, Call frames) onto one two-phase ContainerActivation mechanism that structurally enforces reset-before-readiness * Guard against re-activating a CFG that is still executing (re-registration reset current_block and transitions mid-flight) * Track nested containers: TailLoop/CFG children of loop bodies and cases queue at expansion (CFGs gated on readiness like Calls), body/case completion waits for them, and completed loops/CFGs run their parent-container hooks * Add a completion-time reachability audit: every child of every executed container region must be processed or provably inert, catching starvation invisible to queue bookkeeping; Call-frame resets invalidate the previous invocation's records * Implement ipow (wrapping square-and-multiply), idivmod_s/u with checked variants (Euclidean q,r pair; m=0 faults unchecked and error-Sums checked), and itobool/ifrombool, pinned by a builder-driven executor test * Model int widths: classification reads the op's BoundedNat log_width, values store canonically sign-extended per width, unsigned reads mask, shifts drop past-width bits, rotates/popcnt/clz/ctz work within N bits, and widen_u zero-extends from the source width * Support higher-order array scan (per-element execution through Call-frame machinery for both CFG and plain-dataflow function bodies, with LoadFunction producing first-class FuncRef values), parse result labels from typed String args instead of Debug scraping, and flip conditional_x to assert clean completion with its captured result array * Raise on measurement outcomes with no queued measurement to bind to (driver/engine batch disagreement) instead of silently dropping them * Capture the entrypoint CFG's classical return values and surface them for pure-classical programs (results key 'return' / 'return_N'), un-xfailing the two return-capture tests * Rewrite the seven guppylang-0.21-dead test programs (discard for linearity, array comprehensions with literal sizes, measure_array instead of move-out-of-subscript) -- the guppy tree now has zero xfails * Add generative program fuzzing: 20 seeded random classical guppy programs checked against a plain-Python reference evaluator via the X-anchor trick * Fold in Codex round-8: entrypoint-based FuncDefn gating (dead functions no longer execute or clobber returns), symmetric Call/scan frame ownership with cross wake-ups, unsigned width conversions reinterpret canonical storage at the source width (iwiden_u/inarrow_u/imin_u/imax_u), and error Sums carry the spec's error payload * Panel-2 batch 1: out-of-range Conditional/TailLoop tags poison, TailLoop control resolution gates on body completion, nodes_inside_cases rebuilds on reset, poison surfaces at loop entry, bare DFG containers fault loudly, pending_conditionals is a set, pending_func_calls is a deduped FIFO, dead Tag audit exemption removed * Panel-2 batch 2: TryQAlloc emits a real Option Sum carrying the qubit, RandomInt/RandomIntBounded store canonically at int<5> with unsigned bound reads, RandomAdvance faults on backtracking and unboundedly large deltas, result_uint/result_array_uint bit-reinterpret canonical storage, and unresolved symbolic angles fault instead of defaulting to identity * Panel-2 batch 3: readiness treats a Conditional with an active case as not-ready (one-shot input copiers no longer fire early), case payload offsets derive from the type row, loop-continue clears stale just-input wires, LoadConstant children count in block emptiness/completion with extra pending-branch wake-ups, and empty-block/scan-passthrough chains iterate instead of recursing * Panel-2 batch 4: scan frames carry LoadFunction type args (generic scanned functions resolve load_nat), trunc_s/u range-check and canonicalize at the op's width, iu_to_s/is_to_u fault out of range per spec, shadowed divergent arms deleted (float comparisons, convert aliases, nonexistent bit-count ops) with fmax/fmin/fpow confirmed live, prelude.exit faults explicitly, and ConstUsize/ConstError constants parse * Panel-2 batch 5: de-vacuum round 2 (phase/rotation/boolean/feedback/conditional/QFT/Hadamard tests assert real distributions, backend-unavailable skips honestly, Bell/Grover pins exact), the two skip-marker constructs un-skipped (RUS while loop reports via result(), deep circuit passes), interference test pins the correct 50/50 physics, and the Python-vs-HUGR divergent regimes (negative divisors, logical shifts, past-width shifts) pinned with spec-derived expectations * Rename the pending_bool_reads parking lot to deferred_nodes (it holds every deferred op kind, not just bool reads) and document pending_conditionals accurately * Performance: the work queue gains a membership mirror (O(log n) contains, dedup on push) and the loaded Hugr lives behind an Arc so per-round and per-wave handles stop deep-cloning the graph -- guppy tree wall time drops ~60% * futures.Read produces the future's declared type: LazyMeasureLeaked futures resolve to Int (preserving leak values) instead of collapsing to Bool * RandomAdvance jumps in O(log delta) both directions: xorshift64 is linear over GF(2), so advancement is a 64x64 bit-matrix power and backtracking uses the 2^64-1 period -- the step ceiling and backtracking fault are gone, pinned by jump-vs-stepping and round-trip tests * Guard quantum-op qubit ids against the simulator's capacity at batch dispatch, naming the op and capacity instead of failing opaquely inside the simulator * Close the capacity-guard hole Codex round-9 found: MZ-batching lookahead now validates each consumed command's qubits, via a shared check_qubit_capacity helper on both dispatchers * Fold in round-10 two-arm verification: successor Input wires clear before block-output propagation (stale-iteration values starve loudly), block/CFG payload offsets derive from type-level arity, unknown transition successors poison instead of spinning past the ceiling, extension Faults skip the completion cascades, synchronously-completed scans no longer re-park as false stalls, NewRNGContext reads the seed's canonical bit pattern, pass-through ops defer on missing inputs, DFG containers flatten explicitly, and impossible scan-launch states fault loudly * Pin the divergent-regime classical semantics against the Selene reference (bool-encoded: int result reporting is unlinked locally, and hugr-core's ishr const-folder breaks on constant past-width shifts -- both noted) * Consolidate the settled-node predicate: one HugrEngine::node_settled (processed and no active container owns it) backs readiness and all four completion checks, and all_predecessors_ready becomes a method, ending the map-threading at eleven call sites * Classical values trace through DFG boundaries (flattening parity with qubit tracing: a DFG node's outputs resolve at its Output child, its Input node at the outer wires), closing the documented classical-DFG residual with a nested-DFG pinning test * Fold in third-panel findings: measurement replay becomes fill-only with purge-on-reactivation retention and post-replay resolver re-runs, the classical executor resolves inputs through the tracing layer (pinned end-to-end: a nested-DFG op previously deferred forever), qubit tracing crosses DFG boundaries with depth-capped recursion, Call arguments and conditional virtual payloads clear stale state before rewrite, and the fail-loud edges close (Engine::process with pending quantum work, gate modifiers, the gate-emitter catch-all, the empty-queue stall check, port-keyed return capture, global_phase deferral) with capacity-guard dispatcher tests replacing the vacuous allocation test * Fold in round-11 verification: boundary copiers and resolve_qubits read through the DFG-tracing layer (a gate on a DFG output ran on a phantom qubit), conditional Sum payloads move to a dedicated map ending the real-port aliasing, TailLoop/Call inputs clear stale state and gain fill-only post-measurement repair, block re-activation resets descend flattened DFG interiors, replay edges carry cascade ids so within-cascade chains survive purging and only the latest cascade refills, return capture is positional at collection with signature-derived arity, and batch scheduling counts builder messages so handler-emitted commands are never dropped * Raise idna floor to 3.18 in docs requirements, matching Dependabot #323 * Allow workflow_dispatch on the optional-dependency postmerge lane and dedupe exp/** in rust-test path filters * Add workflow_dispatch trigger to rust-test.yml so the suite can be run manually against a branch * Build the exp wheel in the postmerge lane: pytest collection imports tests/qec modules that need pecos_rslib_exp (lane has failed on dev since those tests landed) * Keep LLVM out of the base pecos-rslib wheel: split pecos's hugr feature into lean hugr (interpreter) and hugr-qis (LLVM compile chain), move compile_hugr_to_qis to the pecos-rslib-llvm wheel and result_tags/envelope loading to pecos-hugr, lower HUGR to QIS at runtime via the LLVM wheel when a QIS/Selene classical engine is selected, and re-attach the stored program when classical() swaps the engine builder (LLVM 21's Windows build links zlib.dll, which broke clean-machine imports of the base wheel) * Raise pr-core gate timeouts: the python job timed out at 45 min on a cold-cache build of a large dependency change
Member
|
@dependabot rebase |
Contributor
Author
|
Looks like this PR has been edited by someone other than Dependabot. That means Dependabot can't rebase it - sorry! If you're happy for Dependabot to recreate it from scratch, overwriting any edits, you can request |
Member
|
@dependabot recreate |
Contributor
Author
|
Looks like idna is up-to-date now, so this is no longer needed. |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Updates the requirements on idna to permit the latest version.
Changelog
Sourced from idna's changelog.
... (truncated)
Commits
f39ea90Release 3.1840f4e40Pre-release 3.18rc01a5bf80Merge pull request #253 from kjd/lenient-decode5bbb26fMerge branch 'master' into lenient-decodec532baeRename decode() lenient= option to display= (issue #248)0b1758bMerge pull request #252 from kjd/release-3.17f48619cRelease 3.177421ba8Pre-release 3.17rc022ebb73Merge pull request #251 from kjd/structure-optimizations2a7ac0aDrop redundant parallel-arrays comment from uts46data