From cfa5439e2f4e35ffaab2843d3deb2f4d06496e08 Mon Sep 17 00:00:00 2001 From: Austin Doolittle Date: Sun, 21 Jun 2026 13:11:48 -0400 Subject: [PATCH 1/4] [MAX] Remove syncs when batch contents change for constrained decoding (#89282) MODULAR_ORIG_COMMIT_REV_ID: 20b82e24ee0bdc3071df1d62c09a03cfdd12e8a2 --- docs/max/nightly-changelog.md | 10 + .../overlap_text_generation.py | 752 ++++++-------- .../pipelines/lib/pipeline_variants/utils.py | 96 +- .../test_graph_construction.py | 3 +- .../nn/test_structured_output_overlap_gpu.py | 6 + .../test_overlap_text_generation_pipeline.py | 974 ++++++++---------- ...st_overlap_text_generation_pipeline_gpu.py | 2 +- 7 files changed, 845 insertions(+), 998 deletions(-) diff --git a/docs/max/nightly-changelog.md b/docs/max/nightly-changelog.md index ef1ff9cf723..d5efd998d43 100644 --- a/docs/max/nightly-changelog.md +++ b/docs/max/nightly-changelog.md @@ -28,6 +28,16 @@ This version is still a work in progress. ### Inference server +- Reduced per-iteration latency for structured-output (constrained decoding) + requests on speculative-decode models. The overlap pipeline now enqueues the + asynchronous FSM-advance and bitmask compute once the next iteration's batch + order is known, so the bitmask is written directly in the consuming batch's + row order. This removes both the host-synchronization point that previously + stalled the GPU-feeding thread when the batch composition changed between + iterations and the device-side gather that earlier reconciled the order. The + improvement applies across all six supported speculative-decode architectures + (Kimi K2.5 MLA and MHA, DeepseekV3 MTP and Eagle3, Gemma 4 MTP, + and EAGLE Llama 3). - Constrained decoding (structured output) now unpacks the grammar bitmask on the GPU. The packed `int32` bitmask is transferred to device as-is and unpacked and applied to the logits in a single fused kernel diff --git a/max/python/max/pipelines/lib/pipeline_variants/overlap_text_generation.py b/max/python/max/pipelines/lib/pipeline_variants/overlap_text_generation.py index df3765ee8a5..bc531eea3f2 100644 --- a/max/python/max/pipelines/lib/pipeline_variants/overlap_text_generation.py +++ b/max/python/max/pipelines/lib/pipeline_variants/overlap_text_generation.py @@ -60,9 +60,7 @@ from __future__ import annotations import copy -import dataclasses import logging -import threading from collections.abc import Callable, Iterator, Sequence from contextlib import contextmanager from pathlib import Path @@ -180,14 +178,6 @@ _OOB_IDX = np.iinfo(np.int32).min -# Log that the async bitmask callback is lagging, but keep waiting for it. -_CALLBACK_LAG_WARN_S = 5.0 -# A live callback always signals via its ``finally``; exceeding this means the -# worker never ran (dispatch failure, AsyncRT shutdown), so we log and proceed rather than -# block the scheduler indefinitely. -_CALLBACK_DEADLINE_S = 120.0 - - @runtime_checkable class _UnifiedSpecDecodeInputs(Protocol): tokens: Buffer @@ -369,43 +359,12 @@ class SpecDecodeState: has_precomputed_bitmask: bool = False """True when a CUDA host callback has computed a bitmask for the next batch.""" - callback_request_ids: list[RequestID] = dataclasses.field( - default_factory=list - ) - """Request IDs of the batch the callback last computed bitmasks for, in - row order. - - Used by ``_assign_bitmask_inputs`` to decide whether the precomputed - bitmask can be adopted as-is or must be recomputed (composition / order - change). - """ - overlap_state: StructuredOutputOverlapState | None = None """Flag + pinned/device bitmask buffers for constrained-decoding overlap. ``None`` when structured output is globally off (no vocab size). Owned for the lifetime of :class:`SpecDecodeState`. """ - last_callback_done_event: threading.Event | None = None - """Set by the most recent async bitmask callback's worker after it - writes pinned. ``_assign_bitmask_inputs`` waits on it before - ``sync_prime`` so the worker can't overwrite ``prime()``'s pinned - writes. Lives on the process-lifetime state because ``_prev_batch`` - is cleared between requests.""" - - realized_draft_tokens_host: npt.NDArray[np.int64] | None = None - """Host-realized EAGLE drafts for the current batch, row-permuted from the - prev batch's ``next_draft_tokens_host`` via the realize map (the same - permutation ``realize_future_tokens`` applies on device). - - Set only when the current batch verifies drafts and the prev batch did not - (``prev.spec_decode.fsm_advanced_by_callback`` is False) -- i.e. exactly the - synchronous-fill case, where the early-sync guard has already made - ``next_draft_tokens_host`` host-complete (D2H copy finished). ``None`` - otherwise. Consumed by ``_assign_bitmask_inputs`` on the synchronous-fill - path so the speculative bitmask is built from the real drafts the GPU - verifies, not MAGIC placeholders.""" - @classmethod def load( cls, @@ -1435,22 +1394,6 @@ class _AsyncSpecDecodeHostBuffers: next_draft_tokens_host: DevicePinnedBuffer -@dataclass -class _CallbackInputs: - """Numpy views into the persistent pinned buffers for the bitmask callback. - - Captured before enqueuing the async bitmask CUDA host callback. - - The closure binds these views by reference; the callback body reads/writes - through them when it eventually fires on the CUDA driver thread. - """ - - bonus_tokens_np: npt.NDArray[np.int64] - num_accepted_np: npt.NDArray[np.int64] - accepted_draft_tokens_np: npt.NDArray[np.int64] - next_draft_tokens_np: npt.NDArray[np.int64] - - @final class OverlapTextGenerationPipeline( TextGenerationPipelineInterface[TextGenerationContextType], @@ -1923,8 +1866,7 @@ def _warmup_model_inputs( # Set all-valid packed bitmask for warmup (unconstrained). # Shape: [batch_size, num_speculative_tokens + 1, # packed_vocab_size]; -1 = all bits set = all tokens valid. - # The overlap path replaces the single device-side - # bitmask input with a (pinned, wait_payload, scratch) + # The overlap path binds a (pinned, wait_payload, scratch) # triple and primes the completion flag so each warmup # replay's in-graph wait passes immediately. overlap_state = self._spec_decode_state.overlap_state @@ -1938,21 +1880,10 @@ def _warmup_model_inputs( dtype=np.int32, ) overlap_state.prime(prime_np) - # Bind the persistent pinned bitmask + device - # scratch via the cached-view helper. The helper - # returns the SAME ``Buffer`` view object every - # time it is called with this ``(total_batch, - # num_positions)`` key, including across warmup - # capture and every steady-state replay. Reusing - # the same object is what makes - # ``GraphCaptureRunner.replay``'s per-input - # preface ``inplace_copy_from`` short-circuit - # via ``self is src`` (the identity check at - # ``Buffer.inplace_copy_from``). Building a fresh - # view (e.g. via ``flat[:N].view(...)``) every - # iter would alias the same memory but fail the - # identity check, and the preface would - # materialize a real copy on every replay. + # Bind via the cached-view helper: the same Buffer view + # objects are returned at capture and every replay, so + # GraphCaptureRunner.replay's preface inplace_copy_from + # short-circuits via the self-is-src identity check. pinned_view, scratch_view = overlap_state.get_input_views( total_batch, num_positions ) @@ -2289,12 +2220,6 @@ def _run_forward( ) if debug_verify_model_inputs is not None: debug_verify_model_inputs.tokens = model_inputs.tokens - # Save off realized draft tokens (None unless realize produced them for the synchronous-fill case). - if self._spec_decode_state is not None: - self._spec_decode_state.realized_draft_tokens_host = ( - realized_draft_tokens_host - ) - # Compute speculative bitmasks here, as late as possible before graph # replay, so that all model-input preparation above can overlap with # the CUDA host callback computing the bitmask on the driver thread. @@ -2325,6 +2250,7 @@ def _run_forward( context_batch=inputs.flat_batch, draft_tokens_np=draft_tokens_np, num_draft_tokens_to_verify=num_draft_tokens_to_verify, + realized_draft_tokens_host=realized_draft_tokens_host, ) # Execute the model and get next tokens. @@ -2500,17 +2426,31 @@ def _assign_bitmask_inputs( context_batch: list[TextGenerationContextType], draft_tokens_np: npt.NDArray[np.int64], num_draft_tokens_to_verify: int, + realized_draft_tokens_host: npt.NDArray[np.int64] | None = None, ) -> None: """Populate the structured-output bitmask graph inputs. - Sets the (pinned, wait_payload, device_scratch) triple on + Binds the (pinned, wait_payload, device_scratch) triple on ``model_inputs`` from :class:`StructuredOutputOverlapState`. - The pinned source is either (a) already populated by the prior - iteration's async callback when ``has_precomputed_bitmask`` is - set and the callback's row order still matches this batch, or - (b) computed synchronously on the main thread via - :meth:`StructuredOutputOverlapState.prime`. In both cases the - flag is at ``1`` by the time the in-graph wait fires. + + Steady state (a callback ran): the async callback enqueued at the head + of :meth:`execute` is the **sole writer** of the ``[0, batch)`` bitmask + rectangle. It advanced the producing batch's FSM and wrote every + consumer row directly in this batch's row order -- resetting any row it + cannot attribute to -1 -- then signalled the completion flag. This + method therefore performs no synchronous bitmask fill; it only binds the + graph-input views. With a single writer there is no main-thread write to + race the in-flight callback, and the model graph consumes the bitmask in + place with no device gather and no host wait. + + Cold start (no callback ran -- prefill->first-decode, or the first + iteration after a non-verify batch): every row is computed + synchronously via :meth:`StructuredOutputOverlapState.prime`, which + writes rows ``[0, batch)`` and signals the flag so the first replay's + wait passes immediately. This is the only path that fills newly-admitted + rows; the scheduler routes every fresh or resumed request through it + (such a request has ``generated_length == 0``, so the batch does not + verify drafts and the callback is left unsent). """ assert self._spec_decode_state is not None overlap_state = self._spec_decode_state.overlap_state @@ -2518,109 +2458,50 @@ def _assign_bitmask_inputs( "_assign_bitmask_inputs requires structured output to be enabled" ) - # Determine whether the prior async callback already wrote - # pinned rows for this batch's request_ids in this exact - # order. If so, no work to do -- the trampoline will signal - # the flag and the in-graph wait will pass when the captured - # graph reaches it. Otherwise (cold start, composition - # change, ordering change), compute synchronously and call - # ``prime`` to populate pinned and signal the flag. spec_state = self._spec_decode_state batch_size = len(context_batch) - # Must match the captured-graph shape; otherwise - # ``get_input_views`` raises and the runtime buffer aliases the - # wrong rows of the persistent pinned/scratch storage. When - # ``num_draft_tokens_to_verify == 0`` (prefill -> decode - # boundary), ``compute_speculative_bitmasks`` writes only slot 0 - # and leaves the trailing slots unconstrained (all bits set, i.e. - # ``-1`` in the packed int32 bitmask output). + # When num_draft_tokens_to_verify == 0 (prefill->decode boundary), + # compute_speculative_bitmasks writes only slot 0 and leaves + # trailing slots unconstrained (all bits set, i.e. -1 in the + # packed int32 bitmask). num_positions = overlap_state.num_positions - callback_rids = spec_state.callback_request_ids callback_available = spec_state.has_precomputed_bitmask - # Consumed this iteration regardless of how it is used below. spec_state.has_precomputed_bitmask = False - # Synchronous fills build the bitmask from the real drafts realize_future_tokens - # scattered onto the device buffer (host mirror), not the MAGIC - # placeholders in draft_tokens_np. Non-None only on the synchronous-fill path - # (see realized_draft_tokens_host); falls back to draft_tokens_np otherwise. - drafts = ( - spec_state.realized_draft_tokens_host - if spec_state.realized_draft_tokens_host is not None - else draft_tokens_np - ) - - if callback_available and self._callback_layout_matches( - context_batch, callback_rids - ): - # Fast path: the callback wrote pinned in this exact row order, so - # the in-graph wait gates the H2D directly -- zero-copy, no wait. - # The event is left for the next iter's enqueue to overwrite. - pass - else: - # Wait for the prior callback so its FSM advance and pinned write - # are done: synchronous fills below read a current FSM, and gather reads - # the callback's pinned rows. Keep waiting through normal lag (warn - # at 5s); only proceed at the 120s dead-worker deadline. - prev_evt = spec_state.last_callback_done_event - if prev_evt is not None and not prev_evt.is_set(): - if not prev_evt.wait(timeout=_CALLBACK_LAG_WARN_S): - logger.warning( - "Async bitmask callback lagging >%.0fs; still waiting. " - "batch_request_ids=%s callback_request_ids=%s", - _CALLBACK_LAG_WARN_S, - [str(ctx.request_id) for ctx in context_batch], - [str(r) for r in (callback_rids or [])], - ) - remaining = _CALLBACK_DEADLINE_S - _CALLBACK_LAG_WARN_S - if not prev_evt.wait(timeout=remaining): - # Worker never signaled (likely a dead stream / - # shutdown). Proceed rather than hang; a stale bitmask - # self-heals via the matcher-rejection (unconstrained) path. - logger.error( - "Async bitmask callback did not complete within " - "%.0fs; proceeding with a possibly-stale bitmask. " - "batch_request_ids=%s callback_request_ids=%s", - _CALLBACK_DEADLINE_S, - [str(ctx.request_id) for ctx in context_batch], - [str(r) for r in (callback_rids or [])], - ) - spec_state.last_callback_done_event = None - - if callback_available: - # Adopt the callback's row for each continuing request (gather - # by request_id, robust to reorder / completion / growth); - # synchronous-fill only rows with no FSM state to advance. - bitmask_np = self._gather_bitmask( - context_batch, callback_rids, drafts, num_positions - ) - else: - # No callback output to adopt: every row is new or was advanced - # synchronously, so a full synchronous fill reads a current FSM. - bitmask_np = ( - self._structured_output.compute_speculative_bitmasks( - context_batch=context_batch, - draft_tokens=drafts, - num_positions=num_positions, - ) - ) - # ``prime`` writes the leading rows of pinned and signals the flag - # so the in-graph wait passes when the captured graph reaches it. + if not callback_available: + # Cold start: no callback advanced the FSM (prefill->first-decode, + # or first iter after a non-verify batch). Compute every row + # synchronously in this batch's order; prime writes rows + # [0, batch) and signals the flag. Build the bitmask from real + # drafts -- the realized host mirror of draft tokens, not MAGIC + # placeholders. ``compute_speculative_bitmasks`` also initialises + # ctx.matcher for any fresh constrained row, so this is the path + # that admits new and resumed requests. + drafts = ( + realized_draft_tokens_host + if realized_draft_tokens_host is not None + else draft_tokens_np + ) + bitmask_np = self._structured_output.compute_speculative_bitmasks( + context_batch=context_batch, + draft_tokens=drafts, + num_positions=num_positions, + ) overlap_state.prime(bitmask_np) + else: + # Steady state: the head-of-execute callback already wrote every + # row -- it is the sole writer of the [0, batch) rectangle (advanced + # the producing batch's FSM, wrote each consumer row in this batch's + # order, signalled the flag). Nothing to fill here; the binding + # below is all that remains. With no second writer the pinned buffer + # the in-graph H2D reads is never raced. + pass - # Wire the graph inputs via the cached-view helper. The - # helper returns the SAME ``Buffer`` view objects every - # time it is called with this ``(batch_size, - # num_positions)`` key -- including across warmup capture - # and every steady-state replay. That object identity is - # what makes ``GraphCaptureRunner.replay``'s preface - # ``inplace_copy_from`` short-circuit via ``self is src`` - # at ``Buffer.inplace_copy_from``; otherwise the engine - # would materialize a real DtoD copy of the device scratch - # (and a real CPU-side memcpy through the pinned buffer's - # mapping) on every replay even though src and dst alias - # the same underlying storage. + # Bind the graph inputs via the cached-view helper so the same Buffer + # objects are passed at warmup capture and every replay — + # GraphCaptureRunner.replay's preface inplace_copy_from short-circuits + # via the self-is-src identity check, avoiding a real device memcpy. pinned_view, scratch_view = overlap_state.get_input_views( batch_size, num_positions ) @@ -2628,138 +2509,15 @@ def _assign_bitmask_inputs( model_inputs.wait_payload = overlap_state.wait_payload model_inputs.device_bitmask_scratch = scratch_view - @staticmethod - def _callback_layout_matches( - context_batch: list[TextGenerationContextType], - callback_rids: list[RequestID], - ) -> bool: - """Whether the callback's rows match this batch's exact order.""" - if len(context_batch) > len(callback_rids): - return False - for idx, ctx in enumerate(context_batch): - if ctx.matcher is None: - # New constrained row (matcher not built) needs a synchronous fill. - if ctx.grammar is not None or ctx.json_schema is not None: - return False - continue - if callback_rids[idx] != ctx.request_id: - return False - return True - - def _gather_bitmask( - self, - context_batch: list[TextGenerationContextType], - callback_rids: list[RequestID], - draft_tokens_np: npt.NDArray[np.int64], - num_positions: int, - ) -> npt.NDArray[np.int32]: - """Gather continuing rows from the callback; synchronous-fill only new rows. - - The callback advanced the FSM and wrote its rows before signaling - ``done_event`` (already waited on), so gathered rows are current and - the read comes before the sync path's write. - """ - spec_state = self._spec_decode_state - assert spec_state is not None - overlap_state = spec_state.overlap_state - assert overlap_state is not None - callback_pinned = overlap_state.pinned_bitmask.to_numpy() - rid_to_row = {rid: j for j, rid in enumerate(callback_rids)} - - assembled = np.empty( - ( - len(context_batch), - num_positions, - overlap_state.packed_vocab_size, - ), - dtype=np.int32, - ) - # Rows the callback didn't cover fall to the synchronous fill. ``src is - # None`` means the request wasn't in the prev (callback) batch -- a - # preempted-then-resumed decode -- so it has no prev-batch FSM state to - # gather and its bitmask is built from scratch. - sync_indices: list[int] = [] - for i, ctx in enumerate(context_batch): - src = rid_to_row.get(ctx.request_id) - if src is not None and not ctx.is_initial_prompt: - assembled[i] = callback_pinned[src] - else: - sync_indices.append(i) - - if sync_indices: - sync_bitmask = self._structured_output.compute_speculative_bitmasks( - context_batch=[context_batch[i] for i in sync_indices], - draft_tokens=draft_tokens_np[sync_indices], - num_positions=num_positions, - ) - for k, i in enumerate(sync_indices): - assembled[i] = sync_bitmask[k] - return assembled - - def _capture_callback_inputs( - self, - spec_state: SpecDecodeState, - batch_size: int, - num_draft_tokens_to_verify: int, - next_draft_k: int, - ) -> _CallbackInputs: - """Capture numpy views into the persistent pinned buffers. - - Used by the async bitmask callback closure. - - Must be called BEFORE the callback is enqueued so the closure binds - live views into persistent buffers. DevicePinnedBuffer.to_numpy() - does not synchronize (documented). Using Buffer.to_numpy() on a - view/slice would go through the base Buffer path, which may - synchronize before reading device-associated memory. - - The D2H copies into these persistent buffers were enqueued earlier - on the same CUDA stream; stream ordering guarantees the data is - valid when the callback fires. - """ - with Tracer("convert_buffers_to_np_views"): - assert spec_state.persistent_bonus_tokens_pinned is not None - assert spec_state.persistent_num_accepted_pinned is not None - assert ( - spec_state.persistent_accepted_draft_tokens_pinned is not None - ) - assert spec_state.persistent_next_draft_tokens_pinned is not None - bonus_tokens_np = ( - spec_state.persistent_bonus_tokens_pinned.to_numpy()[ - :batch_size - ] - ) - num_accepted_np = ( - spec_state.persistent_num_accepted_pinned.to_numpy()[ - :batch_size - ] - ) - accepted_draft_tokens_np = ( - spec_state.persistent_accepted_draft_tokens_pinned.to_numpy()[ - :batch_size, :num_draft_tokens_to_verify - ] - ) - next_draft_tokens_np = ( - spec_state.persistent_next_draft_tokens_pinned.to_numpy()[ - :batch_size, :next_draft_k - ] - ) - return _CallbackInputs( - bonus_tokens_np=bonus_tokens_np, - num_accepted_np=num_accepted_np, - accepted_draft_tokens_np=accepted_draft_tokens_np, - next_draft_tokens_np=next_draft_tokens_np, - ) - def _build_bitmask_callback( self, context_batch: list[TextGenerationContextType], + output_context_batch: list[TextGenerationContextType], bonus_tokens_np: npt.NDArray[np.int64], num_accepted_np: npt.NDArray[np.int64], accepted_draft_tokens_np: npt.NDArray[np.int64], next_draft_tokens_np: npt.NDArray[np.int64], overlap_pinned_np: npt.NDArray[np.int32], - done_event: threading.Event, ) -> Callable[[], None]: """Build a callback closure that advances FSM then computes bitmasks. @@ -2772,23 +2530,26 @@ def _build_bitmask_callback( callback. Args: - context_batch: List of generation contexts for the batch. + context_batch: Generation contexts of the producing batch (the one + whose FSM is advanced). Indexes the token arrays below. + output_context_batch: Generation contexts of the consuming batch, + in its logits row order. The bitmask is written in this order, + so the model graph consumes it without a device gather. Equals + ``context_batch`` only when the batch did not change. bonus_tokens_np: Bonus tokens array, shape [batch]. num_accepted_np: Accepted draft token counts, shape [batch]. accepted_draft_tokens_np: Draft tokens verified, shape [batch, K]. next_draft_tokens_np: Draft tokens for next batch, shape [batch, K]. overlap_pinned_np: Packed int32 bitmask view aliasing the leading rows of :attr:`StructuredOutputOverlapState.pinned_bitmask`, - shape [batch, K+1, packed_vocab]. The callback writes the - packed FSM bitmask here directly in iter-N's row order; the - next iter's in-graph H2D copies it to device, where the GPU - acceptance sampler unpacks and applies it in one fused pass. - ``advance_fsm_and_compute_bitmasks`` resets each row to -1 - (all valid) before filling, so no pre-initialization is needed. - done_event: Set by the callback in a ``finally`` block after - ``overlap_pinned_np`` is fully written, so the next - iter's ``_assign_bitmask_inputs`` can ``wait()`` on it - before ``sync_prime`` to avoid stomping pinned mid-write. + shape [out_batch, K+1, packed_vocab]. The callback writes the + packed FSM bitmask here directly in the consuming batch's row + order; the next iter's in-graph H2D copies it to device, where + the GPU acceptance sampler unpacks and applies it in one fused + pass. ``advance_fsm_and_compute_bitmasks`` owns the whole + rectangle: it resets every row to -1 (all valid) before filling + the continuing rows, so no row is ever left stale and there is + no second writer on the main thread. Returns: A zero-argument callable for use with @@ -2799,9 +2560,10 @@ def _build_bitmask_callback( def callback() -> None: try: # Write the packed int32 FSM bitmask straight into the pinned - # buffer the next iter's in-graph H2D reads. The GPU acceptance - # sampler unpacks and applies it (apply_packed_bitmask), so the - # callback no longer unpacks on the CPU -- this removes the (benchmarked) + # buffer the next iter's in-graph H2D reads, in the consuming + # batch's row order. The GPU acceptance sampler unpacks and + # applies it (apply_packed_bitmask), so the callback no longer + # unpacks on the CPU -- this removes the (benchmarked) # ~600-800us per-step unpack that previously ran here. structured_output.advance_fsm_and_compute_bitmasks( context_batch=context_batch, @@ -2810,6 +2572,7 @@ def callback() -> None: bonus_tokens=bonus_tokens_np, next_draft_tokens=next_draft_tokens_np, bitmask_out=overlap_pinned_np, + output_context_batch=output_context_batch, ) except Exception as e: logger.error( @@ -2821,59 +2584,61 @@ def callback() -> None: # fallback: the model still produces a token, generation # makes forward progress, and the grammar will re-converge # on the next iter. + # + # The callback is the sole writer of this [:curr_batch_size] + # rectangle -- the synchronous new-admission fill was removed + # when bitmask preparation was consolidated here -- so resetting + # the whole view races no main-thread write. (``overlap_pinned_np`` + # already aliases exactly the [:curr_batch_size] consumer rows.) try: overlap_pinned_np[:] = -1 except Exception: pass - finally: - # Signal completion so a downstream ``sync_prime`` waiting - # on this event can proceed without racing the pinned write. - done_event.set() return callback @traced - def _enqueue_async_bitmask_callback( + def _enqueue_prev_bitmask_callback( self, - context_batch: list[TextGenerationContextType], - num_draft_tokens_to_verify: int, - next_draft_k: int, - verify_draft_tokens: bool, + curr_context_batch: list[TextGenerationContextType], ) -> bool: - """Enqueue an async host callback to advance FSM and compute bitmasks. - - Extracts numpy views from persistent DevicePinnedBuffers BEFORE - enqueueing (so the callback closure captures live views into - persistent buffers), then dispatches the callback via - :meth:`StructuredOutputOverlapState.enqueue_async_callback`. The - kickoff trampoline lands on the device's default stream so it - is naturally ordered with the next iter's captured-graph - ``mo.wait_host_value_with_dep`` op; the actual FSM advance + - bitmask compute runs on a separate AsyncRT worker thread and - signals the completion flag when finished. - - Only enqueued for decode batches (verify_draft_tokens=True). - For prefill, the bitmask is computed synchronously on the next - decode iteration via :meth:`StructuredOutputOverlapState.prime`. - - This enables CPU/GPU overlap: the bitmask for batch N+1 is - computed on an AsyncRT worker while the model stream runs - iter N+1's target forward. + """Enqueue the previous batch's FSM-advance + in-order bitmask callback. + + Runs at the head of :meth:`execute`, once this iteration's batch (and + therefore the consumer logits-row order, ``curr_context_batch``) is + known. The async callback advances the producing (previous) batch's + FSM through its committed tokens and writes the packed bitmask for + every row **directly in ``curr_context_batch`` order**, so the model + graph consumes it without a device gather. The callback is the sole + writer of the bitmask rectangle on this path: it is only enqueued when + the whole current batch verifies drafts (so every row continues from + the previous batch), and :meth:`_assign_bitmask_inputs` performs no + synchronous fill when it runs. + + The producing batch's committed/draft tokens are read from the + persistent pinned buffers, which still hold its D2H output (this + iteration's D2H runs later, in ``_execute_spec_decode``). The kickoff + trampoline lands on the device default stream after that D2H, so the + worker observes complete data; it signals the completion flag the next + iter's in-graph ``mo.wait_host_value_with_dep`` gates the H2D on. The + FSM advance + bitmask compute run on a separate AsyncRT worker, so they + overlap this iteration's target forward. + + On success the producing batch's ``fsm_advanced_by_callback`` is set + (its later sync skips the now-redundant FSM advance) and + ``has_precomputed_bitmask`` is primed for + :meth:`_assign_bitmask_inputs`. + + Returns early without enqueuing when there is no previous batch, when + the previous batch did not verify drafts (a prefill / mixed batch has + no committed tokens to advance through -- its successor cold-starts via + prime instead), or when structured output is not configured. Args: - context_batch: Generation contexts for the current batch. - num_draft_tokens_to_verify: Number of draft tokens verified this step, - used to slice the accepted-draft numpy view. - next_draft_k: Number of next draft tokens (K), used to slice the - next-draft numpy view and compute the bitmask position count. - verify_draft_tokens: True when draft tokens are being verified (decode - mode). When False (prefill), the callback is not enqueued. + curr_context_batch: This iteration's contexts, in logits row order. Returns: - True if the callback was enqueued. The worker's completion - event is stashed on ``spec_state.last_callback_done_event`` - for the next iter's ``_assign_bitmask_inputs`` to wait on - before ``sync_prime``. + True if the callback was enqueued. """ if not self._pipeline_config.needs_bitmask_constraints: return False @@ -2888,92 +2653,127 @@ def _enqueue_async_bitmask_callback( ): return False - # Only enqueue the FSM-advancing callback during decode iterations. - # For prefill, contexts have no future tokens to commit so FSM advance - # would race with sync_and_process_outputs. - if not verify_draft_tokens: + prev_batch = self._prev_batch + if prev_batch is None or prev_batch.spec_decode is None: return False - batch_size = len(context_batch) - num_positions = next_draft_k + 1 - callback_inputs = self._capture_callback_inputs( - spec_state=spec_state, - batch_size=batch_size, - num_draft_tokens_to_verify=num_draft_tokens_to_verify, - next_draft_k=next_draft_k, - ) + # Only a verify (decode) batch produced committed tokens to advance the + # FSM through. After a prefill / mixed batch (no draft verification), + # there is nothing to advance; its successor cold-starts the bitmask + # via prime() in _assign_bitmask_inputs, and the prefill batch's own + # FSM advance happens on its (early-)sync path. + if not self._prev_batch_verified_drafts(): + return False + prev_num_draft_tokens_to_verify = ( + prev_batch.spec_decode.num_draft_tokens_to_verify + ) + + # Only enqueue when THIS iteration will also verify drafts -- the + # steady decode path that consumes the callback's bitmask in place. + # If the current batch does not verify (a fresh prefill joined, making + # it a mixed / prefill batch), ``_execute_spec_decode`` clears + # ``has_precomputed_bitmask`` and ``_assign_bitmask_inputs`` cold-starts + # via ``prime`` -- which writes the pinned buffer and signals the flag. + # Enqueuing here too would double-write the buffer and double-signal the + # flag against this enqueue's trampoline reset. Instead leave the + # callback unsent: ``fsm_advanced_by_callback`` stays False, the + # early-sync guard advances the previous batch's FSM, and the cold-start + # prime owns the bitmask. (Matches the predicate in + # ``_should_early_sync_prev_batch``.) + # + # Cost of this fallback: when a mixed batch recurs, the cold-start + # prime recomputes every row's bitmask synchronously, including the + # continuing constrained rows the callback could have produced + # off-thread. The scheduler does not emit mixed batches today, so this + # is dormant. Once mixed batches are supported, preserving overlap here + # means enqueuing the callback for just the continuing subset and + # cold-starting only the genuinely new rows -- deferred until then to + # avoid splitting the prime/callback bitmask ownership (and the flag + # signalling) on a path that cannot yet be exercised or benchmarked. + curr_verifies = all( + ctx.tokens.generated_length > 0 for ctx in curr_context_batch + ) + if not curr_verifies: + return False overlap_state = spec_state.overlap_state assert overlap_state is not None, ( "Async bitmask callback requires structured output to be enabled" ) - # View the leading rows of the persistent pinned bitmask. - # The worker writes here; the captured graph reads here. The - # in-graph ``mo.wait_host_value_with_dep`` gates the captured - # graph's read on the worker's release-store of the flag, so - # the writer and reader cannot race even though they share - # storage. Same lifetime guarantees as the other numpy views - # captured here: the underlying DevicePinnedBuffer outlives - # every callback invocation. + + prev_context_batch = prev_batch.inputs.flat_batch + prev_batch_size = len(prev_context_batch) + next_draft_k = prev_batch.spec_decode.next_draft_tokens_host.shape[1] + num_positions = next_draft_k + 1 + curr_batch_size = len(curr_context_batch) + + # Capture BEFORE enqueue: capture numpy views into the persistent pinned + # buffers so the closure binds live data. Use DevicePinnedBuffer.to_numpy() + # not Buffer.to_numpy() — the latter may synchronize on a view/slice. + with Tracer("convert_buffers_to_np_views"): + assert spec_state.persistent_bonus_tokens_pinned is not None + assert spec_state.persistent_num_accepted_pinned is not None + assert ( + spec_state.persistent_accepted_draft_tokens_pinned is not None + ) + assert spec_state.persistent_next_draft_tokens_pinned is not None + bonus_tokens_np = ( + spec_state.persistent_bonus_tokens_pinned.to_numpy()[ + :prev_batch_size + ] + ) + num_accepted_np = ( + spec_state.persistent_num_accepted_pinned.to_numpy()[ + :prev_batch_size + ] + ) + accepted_draft_tokens_np = ( + spec_state.persistent_accepted_draft_tokens_pinned.to_numpy()[ + :prev_batch_size, :prev_num_draft_tokens_to_verify + ] + ) + next_draft_tokens_np = ( + spec_state.persistent_next_draft_tokens_pinned.to_numpy()[ + :prev_batch_size, :next_draft_k + ] + ) + + # View the leading consumer rows of the persistent pinned bitmask. + # The worker is the sole writer of this [:curr_batch_size] rectangle: it + # writes every row in curr order (every row continues from the producing + # batch on this path). The captured graph reads the whole rectangle, + # gated on the worker's release-store of the flag. Same lifetime + # guarantees as the other captured views: the underlying + # DevicePinnedBuffer outlives every callback invocation. overlap_pinned_np = overlap_state.pinned_bitmask.to_numpy()[ - :batch_size, :num_positions, : + :curr_batch_size, :num_positions, : ] - done_event = threading.Event() with Tracer("build_bitmask_callback"): callback = self._build_bitmask_callback( - context_batch=context_batch, - bonus_tokens_np=callback_inputs.bonus_tokens_np, - num_accepted_np=callback_inputs.num_accepted_np, - accepted_draft_tokens_np=callback_inputs.accepted_draft_tokens_np, - next_draft_tokens_np=callback_inputs.next_draft_tokens_np, + context_batch=prev_context_batch, + output_context_batch=curr_context_batch, + bonus_tokens_np=bonus_tokens_np, + num_accepted_np=num_accepted_np, + accepted_draft_tokens_np=accepted_draft_tokens_np, + next_draft_tokens_np=next_draft_tokens_np, overlap_pinned_np=overlap_pinned_np, - done_event=done_event, ) - # Trampoline + worker dispatch goes on the device's default - # stream. The trampoline's ``flag.reset()`` is therefore - # naturally ordered against the next iter's captured-graph - # ``mo.wait_host_value_with_dep`` (same stream), eliminating - # the cross-stream race where the wait could observe a stale - # ``1`` from iter N's prime / worker N-1's signal and pass - # immediately, DMA'ing stale pinned rows into device scratch. - # - # The trampoline itself is microseconds (atomic store + heap - # alloc + ``MLRT::addTask`` + return). The slow FSM advance - # and bitmask compute happen inside ``fn``, which runs on an - # AsyncRT worker thread off-stream and signals the flag on - # completion -- so overlap with the target forward is - # preserved; only the trampoline body serialises against the - # model stream. - # - # ASSERTION: at the moment we capture - # ``overlap_pinned_np`` and snapshot - # ``callback_request_ids``, both reflect ``context_batch``'s - # row order, and the closure will write into pinned in that - # same order. Downstream ``_assign_bitmask_inputs`` compares - # this captured order against iter-N+1's batch to decide - # whether to adopt the callback's writes in place. If a - # future scheduler refactor decides iter-N+1's row order - # before this enqueue (so the closure could write in - # iter-N+1's order directly), this assertion is the single - # point of truth that needs to be re-evaluated. Today every - # code path in ``_execute_spec_decode`` reaches this site - # with the current-iteration batch fully formed and stable. - assert overlap_pinned_np.shape[0] == len(context_batch), ( - "Overlap pinned-bitmask view row count must match " - "context_batch length at enqueue time." - ) + # The trampoline + worker dispatch goes on the device default stream. + # The trampoline's flag.reset() is therefore naturally ordered against + # this iter's captured-graph wait (same stream), so the wait cannot + # observe a stale 1 from a prior prime / worker signal. The trampoline + # body is microseconds (atomic store + heap alloc + MLRT::addTask + + # return); the slow FSM advance + bitmask compute run inside fn on an + # AsyncRT worker off-stream and signal the flag on completion, so the + # overlap with the target forward is preserved. overlap_state.enqueue_async_callback(callback) - # Snapshot the request IDs in row order so the next iter's - # ``_assign_bitmask_inputs`` can detect whether the precomputed - # bitmask layout still matches. - spec_state.callback_request_ids = [ - ctx.request_id for ctx in context_batch - ] + # The callback advances the producing batch's FSM, so its later sync + # must skip the now-redundant advance. + prev_batch.spec_decode.fsm_advanced_by_callback = True spec_state.has_precomputed_bitmask = True - spec_state.last_callback_done_event = done_event return True def _d2h_spec_decode_outputs( @@ -3184,17 +2984,14 @@ def _execute_spec_decode( # block until the d2h copy is complete, and no more. copy_event = device0.default_stream.record_event() - # Enqueue a CUDA host callback to advance the FSM and compute - # bitmasks for the next iteration, overlapping with GPU work. - # Must be enqueued AFTER copy_event so the callback sees complete - # D2H data. Returns True when the FSM advance is delegated to the - # callback (skip_fsm_advance must be set on the batch accordingly). - fsm_advanced_by_callback = self._enqueue_async_bitmask_callback( - context_batch=context_batch, - num_draft_tokens_to_verify=num_draft_tokens_to_verify, - next_draft_k=next_draft_k, - verify_draft_tokens=verify_draft_tokens, - ) + # The FSM-advance + in-order bitmask callback for THIS batch is not + # enqueued here. It is enqueued at the head of the NEXT execute() + # call (``_enqueue_prev_bitmask_callback``), once that iteration's + # row order is known, so the bitmask is written in the consuming + # batch's order and the model graph needs no device gather. The + # D2H above lands in the persistent pinned buffers the callback + # reads; ``fsm_advanced_by_callback`` starts False and is flipped + # to True by that next-iter enqueue. async_batch = AsyncBatch( inputs=inputs, @@ -3209,7 +3006,7 @@ def _execute_spec_decode( num_accepted_draft_tokens_device=num_accepted_draft_tokens_device, num_accepted_draft_tokens_host=num_accepted_draft_tokens_host, max_seq_len=self._pipeline_model.max_seq_len, - fsm_advanced_by_callback=fsm_advanced_by_callback, + fsm_advanced_by_callback=False, ), think_start_token_id=( self._think_start_token_id @@ -3225,26 +3022,52 @@ def _execute_spec_decode( return async_batch - def _should_early_sync_prev_batch(self) -> bool: - """Return True iff the previous batch must be early-synced. - - Sync happens before this iteration's CUDA host callback is enqueued - in `_execute_spec_decode`. + def _prev_batch_verified_drafts(self) -> bool: + """Return True iff the previous batch ran a verify (decode) step. - Fires only on the prefill→decode transition when structured output is - enabled. Prevents a race where the new callback (running on the CUDA - driver thread, outside the Python GIL) would call - `ctx.matcher.try_consume_tokens` concurrently with this thread's - `ctx.advance_fsm` during the normal sync path. Concurrent - unsynchronized access produces "doesn't satisfy the grammar" errors - and matcher state corruption. + A verify batch has ``spec_decode.num_draft_tokens_to_verify > 0``. + Prefill and mixed batches have zero and are excluded. + """ + return ( + self._prev_batch is not None + and self._prev_batch.spec_decode is not None + and self._prev_batch.spec_decode.num_draft_tokens_to_verify > 0 + ) - All subsequent decode batches have `fsm_advanced_by_callback=True` - (the callback already advanced the FSM), so their sync paths never - touch `ctx.matcher` and full overlap is preserved — the guard does - not fire for them. + def _should_early_sync_prev_batch(self) -> bool: + """Return True iff the previous batch must be early-synced. - Gated on `structured_output.enabled`: when SO is disabled, no + Checked at the head of `execute`, just after + `_enqueue_prev_bitmask_callback` has had its chance to advance the + previous batch's FSM via the async callback. + + Fires whenever no async callback advanced the previous batch's FSM, + i.e. `fsm_advanced_by_callback` is still False after + `_enqueue_prev_bitmask_callback` ran. With structured output enabled + and a previous batch present, that is the case when: + + * the previous batch did not verify drafts (a prefill / mixed + previous batch has no committed tokens to advance through), or + * the current batch does not verify (a fresh prefill joined, making + it a mixed batch): the callback is left unsent so it cannot + double-write the cold-start prime path, or + * the persistent pinned spec-decode buffers are not yet allocated. + + In all of these the previous batch's FSM is still un-advanced. Syncing + it here advances its FSM before this iteration's bitmask compute + (`_assign_bitmask_inputs`, cold-start prime path) reads the matchers, + and before any new callback could touch them. Concurrent unsynchronized + matcher access produces "doesn't satisfy the grammar" errors and state + corruption. + + When a callback did advance the previous batch (the steady + decode→decode path, both batches verifying), it has + `fsm_advanced_by_callback=True` (set by + `_enqueue_prev_bitmask_callback` just above), so its sync path never + advances `ctx.matcher` and full overlap is preserved — the guard does + not fire for it. + + Gated on `needs_bitmask_constraints`: when structured output is off, no callback is ever enqueued, so `fsm_advanced_by_callback` is always False. Without this gate the guard would fire every decode step. @@ -3315,16 +3138,27 @@ def execute( # Spec-decode handles sampling internally. # Remove the condition below when SERVOPT-992 is resolved. if self._spec_decode_state is not None: + # Now that this iteration's batch order is known, enqueue the + # previous batch's FSM-advance + bitmask callback so it writes + # the bitmask directly in THIS batch's row order. This must run + # before the early-sync guard below: it sets the previous + # batch's ``fsm_advanced_by_callback``, which the guard reads to + # decide whether the previous batch still needs a synchronous + # FSM advance (it does only when no callback advanced it, e.g. + # the prefill->decode boundary). + self._enqueue_prev_bitmask_callback( + curr_context_batch=inputs.flat_batch + ) + if self._should_early_sync_prev_batch(): assert self._prev_batch is not None _early_sync_outputs = ( self._prev_batch.sync_and_process_outputs() ) - # FSM is advanced asynchronously by the host callback - # enqueued in ``_execute_spec_decode``. The captured - # graph's ``mo.wait_host_value_with_dep`` blocks the - # in-graph H2D until the worker signals, so the FSM + # FSM is advanced asynchronously by the host callback enqueued + # just above. The captured graph's ``mo.wait_host_value_with_dep`` + # blocks the in-graph H2D until the worker signals, so the FSM # advancement is observed before the sampler runs. curr_batch = self._execute_spec_decode(inputs) else: diff --git a/max/python/max/pipelines/lib/pipeline_variants/utils.py b/max/python/max/pipelines/lib/pipeline_variants/utils.py index 098d2628c88..2b538dc3a62 100644 --- a/max/python/max/pipelines/lib/pipeline_variants/utils.py +++ b/max/python/max/pipelines/lib/pipeline_variants/utils.py @@ -906,29 +906,50 @@ def advance_fsm_and_compute_bitmasks( bonus_tokens: npt.NDArray[np.int64], next_draft_tokens: npt.NDArray[np.int64], bitmask_out: npt.NDArray[np.int32], + output_context_batch: list[TextGenerationContextType] | None = None, ) -> None: """Advance FSM through accepted tokens, then compute bitmasks for the next batch. Combines FSM advancement (Part 1) with bitmask computation (Part 2) for use in a CUDA host callback. Must NOT call any CUDA APIs. - Part 1 permanently advances the FSM through committed tokens from the - current batch (accepted draft tokens followed by the bonus token). This - mirrors what sync_and_process_outputs would do for structured output. - - Part 2 speculatively advances through the next batch's draft tokens to - compute bitmasks, then rolls back to restore the FSM to the state after - Part 1. + Part 1 permanently advances the FSM of every ``context_batch`` request + through its committed tokens (accepted draft tokens followed by the + bonus token). This mirrors what sync_and_process_outputs would do for + structured output, and is independent of the output row order. + + Part 2 owns the **entire** ``output_context_batch`` rectangle and + writes each row's speculative bitmask **in that batch's row order**, by + speculatively advancing the already-advanced matcher through the next + batch's draft tokens and rolling back. Every row is first reset to -1 + (all valid), then each constrained row is filled from its request's + ``next_draft_tokens``. This runs only from a callback enqueued when the + whole current batch verifies drafts, so every consumer row continues + from ``context_batch`` (the scheduler routes fresh/resumed requests + through the cold-start prime path instead; see the caller + ``_enqueue_prev_bitmask_callback`` and ``_assign_bitmask_inputs``). A + row absent from ``context_batch`` would break that invariant and is + asserted against rather than silently mis-filled. Writing directly in + the consumer's row order, with no second writer on the main thread, is + what lets the model graph consume the bitmask without an on-device + gather and without a host wait. Args: - context_batch: List of generation contexts. + context_batch: Requests whose FSM is advanced (the producing batch). + Indexes ``accepted_draft_tokens`` / ``num_accepted`` / + ``bonus_tokens`` / ``next_draft_tokens``. accepted_draft_tokens: Draft tokens verified this batch, shape [batch, K]. num_accepted: Count of accepted draft tokens per request, shape [batch]. bonus_tokens: Bonus (target) tokens per request, shape [batch]. next_draft_tokens: Draft tokens for the next batch, shape [batch, K]. - bitmask_out: Packed int32 bitmask output, shape [batch, K+1, packed_vocab]. - Initialized to -1 (unconstrained) per context before filling. + bitmask_out: Packed int32 bitmask output, shape + [len(output_context_batch), K+1, packed_vocab]. Every row is + reset to -1 (unconstrained) before filling. + output_context_batch: Requests in the consuming batch's row order. + Defaults to ``context_batch`` when the batch did not change. """ + if output_context_batch is None: + output_context_batch = context_batch # This method runs on an AsyncRT worker thread. The main thread # may try to access the same ``ctx.matcher`` via # ``compute_speculative_bitmasks`` for the next iter while this @@ -936,17 +957,20 @@ def advance_fsm_and_compute_bitmasks( # raises ``RuntimeError: Already borrowed`` and the worker dies. # See the comment on ``_matcher_lock``. with self._matcher_lock: + # Part 1: permanently advance every producing-batch matcher + # through its committed tokens. Order-independent of the output + # batch, so it always covers all of ``context_batch`` — which is + # what keeps the batch-level ``skip_fsm_advance`` contract intact + # for the producing batch's later sync. for ctx_idx, ctx in enumerate(context_batch): - bitmask_out[ctx_idx, :, :] = -1 - if ctx.matcher is None: continue - # Part 1: Advance the enforcement state machine through - # committed tokens, one at a time so special tokens (e.g. - # tool-call structural tags) can flip grammar enforcement - # mid-sequence. This mirrors the synchronous - # ``advance_fsm`` in ``context.py`` exactly: + # Advance the enforcement state machine through committed + # tokens, one at a time so special tokens (e.g. tool-call + # structural tags) can flip grammar enforcement mid-sequence. + # This mirrors the synchronous ``advance_fsm`` in + # ``context.py`` exactly: # # * EOS-class tokens are not part of the grammar — they # signal end of generation. Skip the matcher so it @@ -1014,13 +1038,45 @@ def advance_fsm_and_compute_bitmasks( ) ctx.grammar_enforced = False - # Part 2: speculative window for the next batch's bitmasks. + # Part 2: write each output row's speculative bitmask in the + # consuming batch's row order. ``rid_to_src`` maps a request id to + # its slot in the producing batch's ``next_draft_tokens``. + rid_to_src = { + ctx.request_id: i for i, ctx in enumerate(context_batch) + } + for out_idx, ctx in enumerate(output_context_batch): + # The callback owns every consumer row. Reset to -1 (all valid) + # up front so an unconstrained continuing row needs no further + # work and no row is ever left holding a previous iteration's + # bitmask for the next iter's in-graph H2D to copy. + bitmask_out[out_idx, :, :] = -1 + # Invariant: the callback is only enqueued when the whole current + # batch verifies drafts, so every consumer row continues from the + # producing batch -- the scheduler routes every fresh or resumed + # request through the cold-start prime path, never here. A row + # absent from ``context_batch`` (or flagged as an initial prompt) + # would mean that invariant broke; assert rather than index + # ``next_draft_tokens`` with None and silently mis-fill. Running + # inside the callback's try/except, a failure here degrades to + # the safe blanket -1 fallback instead of corrupting the bitmask. + src = rid_to_src.get(ctx.request_id) + assert src is not None and not ctx.is_initial_prompt, ( + f"bitmask callback: row {ctx.request_id} is not an " + "attributable continuing row (absent from the producing " + "batch, or reset to an initial prompt). The callback's " + "single-writer invariant is broken -- a scheduler change " + "that admits new or resumed rows into a verify batch must " + "restore a synchronous fill for them." + ) + if ctx.matcher is None: + # Continuing unconstrained row: all-valid, no fill needed. + continue # A draft that flips enforcement on mid-window causes # downstream slots to be constrained. self._speculatively_fill_bitmask_window( ctx, - drafts=next_draft_tokens[ctx_idx], - bitmask_window=bitmask_out[ctx_idx], + drafts=next_draft_tokens[src], + bitmask_window=bitmask_out[out_idx], ) @traced diff --git a/max/tests/integration/architectures/unified_eagle_llama/test_graph_construction.py b/max/tests/integration/architectures/unified_eagle_llama/test_graph_construction.py index e23f6753fce..d37c736e5cb 100644 --- a/max/tests/integration/architectures/unified_eagle_llama/test_graph_construction.py +++ b/max/tests/integration/architectures/unified_eagle_llama/test_graph_construction.py @@ -130,7 +130,8 @@ def test_input_types_with_structured_output() -> None: # The trailing three inputs are pinned_bitmask (packed int32 tensor), # wait_payload (int64 buffer), and device_bitmask_scratch (packed int32 - # buffer). + # buffer). The bitmask is stored as packed int32 (one bit per vocab token) + # so the GPU acceptance sampler unpacks and applies it in one fused pass. pinned_type = input_types[-3] payload_type = input_types[-2] scratch_type = input_types[-1] diff --git a/max/tests/integration/nn/test_structured_output_overlap_gpu.py b/max/tests/integration/nn/test_structured_output_overlap_gpu.py index 13da4af8997..ef7e3453cf1 100644 --- a/max/tests/integration/nn/test_structured_output_overlap_gpu.py +++ b/max/tests/integration/nn/test_structured_output_overlap_gpu.py @@ -195,6 +195,9 @@ def _build_overlap_smoke_graph( binding rule ("Pinned tensors can only be used in place of CPU graph inputs"), even though the runtime ``DevicePinnedBuffer``'s ``.device`` is the accelerator. + + Both pinned and scratch use int32 because the bitmask is packed: + one bit per vocab token stored in 32-bit words. """ device_ref = DeviceRef.from_device(accelerator) with Graph( @@ -403,6 +406,9 @@ def _build_overlap_smoke_graph_with_output( might let ``execute`` return as soon as work is queued, which would defeat the timing-based hoist detection in :func:`test_in_graph_h2d_is_gated_by_wait_host_value`. + + Both pinned and scratch use int32 because the bitmask is packed: + one bit per vocab token stored in 32-bit words. """ device_ref = DeviceRef.from_device(accelerator) with Graph( diff --git a/max/tests/integration/pipelines/text_generation_pipeline/test_overlap_text_generation_pipeline.py b/max/tests/integration/pipelines/text_generation_pipeline/test_overlap_text_generation_pipeline.py index ba94c13dea7..8e762e3d262 100644 --- a/max/tests/integration/pipelines/text_generation_pipeline/test_overlap_text_generation_pipeline.py +++ b/max/tests/integration/pipelines/text_generation_pipeline/test_overlap_text_generation_pipeline.py @@ -12,7 +12,6 @@ # ===----------------------------------------------------------------------=== # -import threading from types import SimpleNamespace from typing import cast from unittest.mock import MagicMock, call, patch @@ -33,7 +32,6 @@ TextGenerationPipeline, ) from max.pipelines.lib.pipeline_variants.overlap_text_generation import ( - _CALLBACK_LAG_WARN_S, _MAX_GRAPH_CAPTURE_BATCH_SIZE, _OOB_IDX, MAGIC_DRAFT_TOKEN_ID, @@ -722,6 +720,9 @@ def _make_context_with_matcher( # ``grammar_enforced=True``. Default the test context to enforced so # these tests exercise the matcher-advance path. ctx.grammar_enforced = True + # Mark as a continuing (non-initial-prompt) context so Part 2 writes + # its row; is_initial_prompt=True causes Part 2 to skip the row. + ctx._is_initial_prompt = False mock_matcher = MagicMock() ret = 1 if always_accept else 0 mock_matcher.try_consume_tokens = MagicMock(return_value=ret) @@ -744,6 +745,9 @@ def test_unconstrained_context_bitmask_stays_all_minus_one(self) -> None: tokens=TokenBuffer(np.array([1, 2, 3])), ) assert ctx.matcher is None + # Mark as a continuing context so Part 2 resets the row to -1; + # is_initial_prompt=True causes Part 2 to skip the row entirely. + ctx._is_initial_prompt = False bitmask_out = np.zeros((1, 3, 2), dtype=np.int32) @@ -892,6 +896,124 @@ def test_part2_stops_on_deep_copy_when_fsm_rejects_first_draft( # Rollback() should not be used to undo token consumption. scratch.rollback.assert_not_called() + def test_part2_asserts_on_unattributable_output_row(self) -> None: + """Part 2 enforces the single-writer invariant: a consumer row whose + request did not produce this iteration (absent from ``context_batch``) + means the callback was enqueued for a batch it does not own, so it + asserts rather than indexing ``next_draft_tokens`` with None. The + current scheduler never admits such a row into a batch the callback runs + for; the assert guards a future scheduler change (and, inside the + callback's try/except, degrades to the safe blanket -1 fallback).""" + helper = self._make_helper() + ctx_prod, _ = self._make_context_with_matcher() + # A consumer-only row whose request is NOT in the producing batch. + ctx_extra = TextContext( + request_id=RequestID("extra"), + max_length=1000, + tokens=TokenBuffer(np.array([1, 2, 3])), + ) + ctx_extra._is_initial_prompt = False + + bitmask_out = np.full((2, 3, 2), 9, dtype=np.int32) + + with patch("llguidance.numpy.fill_next_token_bitmask"): + with pytest.raises(AssertionError): + helper.advance_fsm_and_compute_bitmasks( + context_batch=[ctx_prod], + accepted_draft_tokens=np.zeros((1, 0), dtype=np.int64), + num_accepted=np.zeros(1, dtype=np.int32), + bonus_tokens=np.array([5], dtype=np.int64), + next_draft_tokens=np.array([[10, 11]], dtype=np.int64), + bitmask_out=bitmask_out, + output_context_batch=[ctx_prod, ctx_extra], + ) + + def test_part2_asserts_on_initial_prompt_continuing_row(self) -> None: + """The other half of the invariant: a row whose request IS in the + producing batch but is flagged ``is_initial_prompt=True`` (e.g. reset + by a future preempt-without-reprefill scheduler) has no producer drafts + and must also assert, not be filled.""" + helper = self._make_helper() + ctx, _ = self._make_context_with_matcher() + # Same request present in both batches, but reset to an initial prompt. + ctx._is_initial_prompt = True + + bitmask_out = np.full((1, 3, 2), 9, dtype=np.int32) + + with patch("llguidance.numpy.fill_next_token_bitmask"): + with pytest.raises(AssertionError): + helper.advance_fsm_and_compute_bitmasks( + context_batch=[ctx], + accepted_draft_tokens=np.zeros((1, 0), dtype=np.int64), + num_accepted=np.zeros(1, dtype=np.int32), + bonus_tokens=np.array([5], dtype=np.int64), + next_draft_tokens=np.array([[10, 11]], dtype=np.int64), + bitmask_out=bitmask_out, + output_context_batch=[ctx], + ) + + def test_part2_reordered_rows_use_producer_drafts_by_request(self) -> None: + """Part 2 writes in CONSUMER row order but reads each row's drafts from + the PRODUCER slot via ``rid_to_src[request_id]``. With a non-identity + permutation (producer [a, b] -> consumer [b, a]) each consumer row must + be filled from its OWN request's ``next_draft_tokens`` -- guards against + a ``src``/``out_idx`` swap, which identity-order tests cannot catch.""" + helper = self._make_helper() + + def _ctx(rid: str) -> TextContext: + c = TextContext( + request_id=RequestID(rid), + max_length=1000, + tokens=TokenBuffer(np.array([1, 2, 3])), + ) + c.grammar_enforced = True + c._is_initial_prompt = False + m = MagicMock() + # Accept committed tokens in Part 1 so the matcher-advance path + # doesn't trip the rejection branch. + m.try_consume_tokens = MagicMock(return_value=1) + c._matcher = m + return c + + ctx_a, ctx_b = _ctx("a"), _ctx("b") + # Producer order [a, b]; a's next drafts = [10, 11], b's = [20, 21]. + next_draft_tokens = np.array([[10, 11], [20, 21]], dtype=np.int64) + bitmask_out = np.full((2, 3, 2), -1, dtype=np.int32) + + # Capture (request_id, drafts, which consumer row) per fill. + calls: list[tuple[str, list[int], bool]] = [] + + def _spy(ctx, drafts, bitmask_window) -> None: # noqa: ANN001 + calls.append( + ( + str(ctx.request_id), + list(np.asarray(drafts)), + np.shares_memory(bitmask_window, bitmask_out[0]), + ) + ) + + with patch("llguidance.numpy.fill_next_token_bitmask"): + with patch.object( + helper, "_speculatively_fill_bitmask_window", side_effect=_spy + ): + helper.advance_fsm_and_compute_bitmasks( + context_batch=[ctx_a, ctx_b], + accepted_draft_tokens=np.zeros((2, 0), dtype=np.int64), + num_accepted=np.zeros(2, dtype=np.int32), + bonus_tokens=np.array([5, 6], dtype=np.int64), + next_draft_tokens=next_draft_tokens, + bitmask_out=bitmask_out, + # Consumer reorders to [b, a]. + output_context_batch=[ctx_b, ctx_a], + ) + + # Consumer row 0 is b -> must use b's producer drafts [20, 21]; + # consumer row 1 is a -> must use a's producer drafts [10, 11]. + assert calls == [ + ("b", [20, 21], True), # row 0 (shares memory with bitmask_out[0]) + ("a", [10, 11], False), # row 1 + ] + class TestBuildBitmaskCallback: """Tests for OverlapTextGenerationPipeline._build_bitmask_callback.""" @@ -917,19 +1039,17 @@ def test_callback_calls_advance_fsm_and_compute_bitmasks(self) -> None: # acceptance sampler unpacks and applies it, so there is no bool target. bitmask_np = np.full((1, 3, 2), -1, dtype=np.int32) - done_event = threading.Event() callback = pipeline._build_bitmask_callback( context_batch=[ctx], + output_context_batch=[ctx], bonus_tokens_np=bonus_np, num_accepted_np=num_acc_np, accepted_draft_tokens_np=draft_np, next_draft_tokens_np=next_draft_np, overlap_pinned_np=bitmask_np, - done_event=done_event, ) callback() - assert done_event.is_set() mock_so.advance_fsm_and_compute_bitmasks.assert_called_once_with( context_batch=[ctx], @@ -938,6 +1058,7 @@ def test_callback_calls_advance_fsm_and_compute_bitmasks(self) -> None: bonus_tokens=bonus_np, next_draft_tokens=next_draft_np, bitmask_out=bitmask_np, + output_context_batch=[ctx], ) def test_callback_logs_error_on_exception(self) -> None: @@ -951,26 +1072,71 @@ def test_callback_logs_error_on_exception(self) -> None: ) pipeline._structured_output = mock_so - done_event = threading.Event() callback = pipeline._build_bitmask_callback( context_batch=[], + output_context_batch=[], bonus_tokens_np=np.array([], dtype=np.int64), num_accepted_np=np.array([], dtype=np.int64), accepted_draft_tokens_np=np.zeros((0, 0), dtype=np.int64), next_draft_tokens_np=np.zeros((0, 0), dtype=np.int64), overlap_pinned_np=np.zeros((0, 0, 0), dtype=np.int32), - done_event=done_event, ) # Must not raise — exceptions are caught and logged callback() - # ``finally`` in the callback signals even on exception so the - # next iter's sync_prime can't deadlock. - assert done_event.is_set() + + def test_callback_exception_resets_whole_rectangle(self) -> None: + """On exception, the fallback resets the entire owned rectangle to -1. + + The callback is the sole writer of the ``[:curr_batch_size]`` rectangle + (the synchronous new-admission fill was consolidated into the callback), + so the blanket reset races no main-thread write. Every row -- continuing + or otherwise -- falls back to all-valid (-1) so generation still makes + forward progress and the grammar re-converges next iter. + """ + pipeline = OverlapTextGenerationPipeline.__new__( + OverlapTextGenerationPipeline + ) + mock_so = MagicMock() + mock_so.advance_fsm_and_compute_bitmasks.side_effect = RuntimeError( + "boom" + ) + pipeline._structured_output = mock_so + + ctx_a = TextContext( + request_id=RequestID("a"), + max_length=100, + tokens=TokenBuffer(np.array([1])), + ) + ctx_a._is_initial_prompt = False + ctx_b = TextContext( + request_id=RequestID("b"), + max_length=100, + tokens=TokenBuffer(np.array([1])), + ) + ctx_b._is_initial_prompt = False + + # Both rows start with a non-(-1) sentinel; the fallback must reset all. + overlap_pinned_np = np.full((2, 3, 2), 9, dtype=np.int32) + + callback = pipeline._build_bitmask_callback( + context_batch=[ctx_a, ctx_b], + output_context_batch=[ctx_a, ctx_b], + bonus_tokens_np=np.zeros(2, dtype=np.int64), + num_accepted_np=np.zeros(2, dtype=np.int64), + accepted_draft_tokens_np=np.zeros((2, 2), dtype=np.int64), + next_draft_tokens_np=np.zeros((2, 2), dtype=np.int64), + overlap_pinned_np=overlap_pinned_np, + ) + + callback() + + # The whole rectangle is reset to all-valid (-1). + assert (overlap_pinned_np == -1).all() -class TestEnqueueAsyncBitmaskCallback: - """Tests for OverlapTextGenerationPipeline._enqueue_async_bitmask_callback.""" +class TestEnqueuePrevBitmaskCallback: + """Tests for OverlapTextGenerationPipeline._enqueue_prev_bitmask_callback.""" def _make_pipeline( self, structured_output_enabled: bool = True @@ -986,16 +1152,48 @@ def _make_pipeline( pipeline._pipeline_config = mock_config return pipeline + def _make_prev_batch( + self, + prev_contexts: list[TextContext], + num_draft_to_verify: int, + next_draft_k: int, + ) -> MagicMock: + """Build a mock AsyncBatch with a spec_decode sub-object. + + ``num_draft_tokens_to_verify`` is a property returning + ``draft_tokens_to_verify_host.shape[1]``, so mock that shape. + ``next_draft_tokens_host.shape`` must be ``(batch, next_draft_k)`` + for the next_draft_k computation in ``_enqueue_prev_bitmask_callback``. + """ + mock_batch = MagicMock() + mock_batch.inputs.flat_batch = prev_contexts + mock_spec_decode = MagicMock() + mock_spec_decode.draft_tokens_to_verify_host = MagicMock() + mock_spec_decode.draft_tokens_to_verify_host.shape = ( + len(prev_contexts), + num_draft_to_verify, + ) + # Set the property value directly so ``num_draft_tokens_to_verify > 0`` + # comparisons in _prev_batch_verified_drafts work (MagicMock does not + # support ``>`` against int by default). + mock_spec_decode.num_draft_tokens_to_verify = num_draft_to_verify + mock_spec_decode.next_draft_tokens_host = MagicMock() + mock_spec_decode.next_draft_tokens_host.shape = ( + len(prev_contexts), + next_draft_k, + ) + mock_spec_decode.fsm_advanced_by_callback = False + mock_batch.spec_decode = mock_spec_decode + return mock_batch + def test_returns_false_when_structured_output_disabled(self) -> None: """Returns False immediately when structured output is not enabled.""" pipeline = self._make_pipeline(structured_output_enabled=False) pipeline._spec_decode_state = MagicMock() + pipeline._prev_batch = MagicMock() - result = pipeline._enqueue_async_bitmask_callback( - context_batch=[], - num_draft_tokens_to_verify=2, - next_draft_k=2, - verify_draft_tokens=True, + result = pipeline._enqueue_prev_bitmask_callback( + curr_context_batch=[], ) assert result is False @@ -1004,22 +1202,32 @@ def test_returns_false_when_spec_decode_state_is_none(self) -> None: """Returns False when spec decode state is not initialized.""" pipeline = self._make_pipeline() pipeline._spec_decode_state = None + pipeline._prev_batch = MagicMock() - result = pipeline._enqueue_async_bitmask_callback( - context_batch=[], - num_draft_tokens_to_verify=2, - next_draft_k=2, - verify_draft_tokens=True, + result = pipeline._enqueue_prev_bitmask_callback( + curr_context_batch=[], ) assert result is False - def test_returns_false_for_prefill_batch(self) -> None: - """Returns False without enqueueing when verify_draft_tokens=False (prefill).""" + def test_returns_false_when_persistent_buffers_missing(self) -> None: + """Returns False when any persistent pinned buffer is absent.""" + pipeline = self._make_pipeline() + mock_spec_state = MagicMock() + mock_spec_state.persistent_bonus_tokens_pinned = None + pipeline._spec_decode_state = mock_spec_state + pipeline._prev_batch = self._make_prev_batch([], 2, 2) + + result = pipeline._enqueue_prev_bitmask_callback( + curr_context_batch=[], + ) + + assert result is False + + def test_returns_false_when_no_prev_batch(self) -> None: + """Returns False when _prev_batch is None (first iteration).""" pipeline = self._make_pipeline() mock_spec_state = MagicMock() - # All persistent pinned buffers present so the prefill-only short-circuit - # is the one that fires (not the buffer-missing one). for name in ( "persistent_bonus_tokens_pinned", "persistent_num_accepted_pinned", @@ -1028,12 +1236,90 @@ def test_returns_false_for_prefill_batch(self) -> None: ): setattr(mock_spec_state, name, MagicMock()) pipeline._spec_decode_state = mock_spec_state + pipeline._prev_batch = None - result = pipeline._enqueue_async_bitmask_callback( - context_batch=[], - num_draft_tokens_to_verify=0, - next_draft_k=2, - verify_draft_tokens=False, + result = pipeline._enqueue_prev_bitmask_callback( + curr_context_batch=[], + ) + + assert result is False + + def test_returns_false_when_prev_batch_has_no_spec_decode(self) -> None: + """Returns False when prev_batch.spec_decode is None (prefill batch).""" + pipeline = self._make_pipeline() + mock_spec_state = MagicMock() + for name in ( + "persistent_bonus_tokens_pinned", + "persistent_num_accepted_pinned", + "persistent_accepted_draft_tokens_pinned", + "persistent_next_draft_tokens_pinned", + ): + setattr(mock_spec_state, name, MagicMock()) + pipeline._spec_decode_state = mock_spec_state + mock_prev = MagicMock() + mock_prev.spec_decode = None + pipeline._prev_batch = mock_prev + + result = pipeline._enqueue_prev_bitmask_callback( + curr_context_batch=[], + ) + + assert result is False + + def test_returns_false_when_prev_num_draft_tokens_zero(self) -> None: + """Returns False when prev batch verified zero draft tokens (prefill).""" + pipeline = self._make_pipeline() + mock_spec_state = MagicMock() + for name in ( + "persistent_bonus_tokens_pinned", + "persistent_num_accepted_pinned", + "persistent_accepted_draft_tokens_pinned", + "persistent_next_draft_tokens_pinned", + ): + setattr(mock_spec_state, name, MagicMock()) + pipeline._spec_decode_state = mock_spec_state + pipeline._prev_batch = self._make_prev_batch( + [], num_draft_to_verify=0, next_draft_k=2 + ) + + result = pipeline._enqueue_prev_bitmask_callback( + curr_context_batch=[], + ) + + assert result is False + + def test_returns_false_when_curr_ctx_not_verifying(self) -> None: + """Returns False when any current context has generated_length == 0. + + ``_enqueue_prev_bitmask_callback`` only fires on the steady decode + path where the callback's bitmask is consumed in place. If the + current batch contains a fresh prompt (generated_length == 0), it + is not a pure decode batch; the callback must not be enqueued. + """ + pipeline = self._make_pipeline() + mock_spec_state = MagicMock() + for name in ( + "persistent_bonus_tokens_pinned", + "persistent_num_accepted_pinned", + "persistent_accepted_draft_tokens_pinned", + "persistent_next_draft_tokens_pinned", + ): + setattr(mock_spec_state, name, MagicMock()) + pipeline._spec_decode_state = mock_spec_state + pipeline._prev_batch = self._make_prev_batch( + [], num_draft_to_verify=2, next_draft_k=2 + ) + + # curr batch has one context with generated_length == 0 (fresh prompt) + curr_ctx = TextContext( + request_id=RequestID("fresh"), + max_length=100, + tokens=TokenBuffer(np.array([1, 2, 3])), + ) + assert curr_ctx.tokens.generated_length == 0 + + result = pipeline._enqueue_prev_bitmask_callback( + curr_context_batch=[curr_ctx], ) assert result is False @@ -1042,8 +1328,6 @@ def test_returns_true_and_enqueues_for_decode_batch(self) -> None: """Returns True and dispatches via overlap_state.enqueue_async_callback for a decode batch.""" pipeline = self._make_pipeline() - # The pipeline's structured_output also drives any nested behavior the - # callback closure may invoke at construction time. pipeline._structured_output.vocab_size = 64 batch_size = 1 @@ -1052,8 +1336,6 @@ def test_returns_true_and_enqueues_for_decode_batch(self) -> None: vocab_size = 64 mock_spec_state = MagicMock() - # Configure each persistent pinned buffer so `to_numpy()` returns a - # writable numpy array of the right shape/dtype. bonus_tokens_pinned = MagicMock() bonus_tokens_pinned.to_numpy.return_value = np.array( [5], dtype=np.int64 @@ -1077,11 +1359,8 @@ def test_returns_true_and_enqueues_for_decode_batch(self) -> None: mock_spec_state.persistent_next_draft_tokens_pinned = ( next_draft_tokens_pinned ) - mock_spec_state.callback_request_ids = [] mock_spec_state.has_precomputed_bitmask = False - # Overlap state must exist (structured output is enabled). Stub the - # pinned_bitmask view so the enqueue path can take its leading rows. overlap_pinned = MagicMock() overlap_pinned.to_numpy.return_value = np.zeros( (batch_size, num_positions, vocab_size), dtype=np.bool_ @@ -1095,44 +1374,46 @@ def test_returns_true_and_enqueues_for_decode_batch(self) -> None: pipeline._disable_overlap = False rid = RequestID("r") - ctx = TextContext( + prev_ctx = TextContext( request_id=rid, max_length=100, tokens=TokenBuffer(np.array([1])), ) + curr_ctx = TextContext( + request_id=RequestID("curr"), + max_length=100, + tokens=TokenBuffer(np.array([1])), + ) + # Simulate one accepted token so generated_length > 0; the callback + # guard requires all current contexts to be in the steady decode path. + curr_ctx.tokens._current_length += 1 + + pipeline._prev_batch = self._make_prev_batch( + [prev_ctx], num_draft_to_verify=num_draft, next_draft_k=num_draft + ) with patch.object( pipeline, "_build_bitmask_callback", return_value=lambda: None, ): - result = pipeline._enqueue_async_bitmask_callback( - context_batch=[ctx], - num_draft_tokens_to_verify=num_draft, - next_draft_k=num_draft, - verify_draft_tokens=True, + result = pipeline._enqueue_prev_bitmask_callback( + curr_context_batch=[curr_ctx], ) assert result is True - # The handoff event is stashed on ``SpecDecodeState`` so the next - # iter's ``_assign_bitmask_inputs`` can wait on it before - # ``sync_prime`` even after ``_prev_batch`` is cleared between - # requests. - assert isinstance( - mock_spec_state.last_callback_done_event, threading.Event - ) mock_overlap_state.enqueue_async_callback.assert_called_once() assert mock_spec_state.has_precomputed_bitmask is True - assert mock_spec_state.callback_request_ids == [rid] - - def test_snapshot_preserves_multi_context_row_order(self) -> None: - """``callback_request_ids`` is snapshotted in the exact order - of ``context_batch``, not sorted. ``_assign_bitmask_inputs`` - on the next iter compares row-for-row against - ``current_request_ids``, so a sort or any reordering here - would make the adoption guard reject every identity case. - Equivalent intent to the deleted - ``test_enqueue_snapshots_callback_request_ids`` test.""" + # The producing batch's flag is set so its sync skips redundant advance. + assert pipeline._prev_batch.spec_decode.fsm_advanced_by_callback is True + + def test_prev_batch_row_order_used_for_continuing_identification( + self, + ) -> None: + """The producing batch's row order drives which curr rows are + identified as continuing in ``_assign_bitmask_inputs``. The rows are + read from ``_prev_batch.inputs.flat_batch`` — not from a snapshot field + on spec_state — so the identity is always derived from the live batch.""" pipeline = self._make_pipeline() pipeline._structured_output.vocab_size = 64 @@ -1167,7 +1448,6 @@ def test_snapshot_preserves_multi_context_row_order(self) -> None: mock_spec_state.persistent_next_draft_tokens_pinned = ( next_draft_tokens_pinned ) - mock_spec_state.callback_request_ids = [] mock_spec_state.has_precomputed_bitmask = False overlap_pinned = MagicMock() @@ -1182,38 +1462,47 @@ def test_snapshot_preserves_multi_context_row_order(self) -> None: pipeline._devices = [MagicMock()] pipeline._disable_overlap = False - # Deliberately non-sorted ordering so a stray sort would be - # caught. - ordered_rids = [ + # Deliberately non-sorted previous-batch ordering so a stray sort + # would corrupt the row-order contract. + prev_rids = [ RequestID("z"), RequestID("a"), RequestID("m"), ] - contexts = [ + prev_contexts = [ TextContext( request_id=rid, max_length=100, tokens=TokenBuffer(np.array([1])), ) - for rid in ordered_rids + for rid in prev_rids ] + pipeline._prev_batch = self._make_prev_batch( + prev_contexts, num_draft_to_verify=num_draft, next_draft_k=num_draft + ) + + curr_ctx = TextContext( + request_id=RequestID("curr"), + max_length=100, + tokens=TokenBuffer(np.array([1])), + ) + # Simulate one accepted token so generated_length > 0; the callback + # guard requires all current contexts to be in the steady decode path. + curr_ctx.tokens._current_length += 1 with patch.object( pipeline, "_build_bitmask_callback", return_value=lambda: None, ): - result = pipeline._enqueue_async_bitmask_callback( - context_batch=contexts, - num_draft_tokens_to_verify=num_draft, - next_draft_k=num_draft, - verify_draft_tokens=True, + result = pipeline._enqueue_prev_bitmask_callback( + curr_context_batch=[curr_ctx], ) assert result is True assert mock_spec_state.has_precomputed_bitmask is True - # Snapshot preserves ``context_batch`` row order verbatim. - assert mock_spec_state.callback_request_ids == ordered_rids + # The producing batch's flag is set; no callback_request_ids field. + assert pipeline._prev_batch.spec_decode.fsm_advanced_by_callback is True class TestInitializeBitmaskWithGrammar: @@ -1461,14 +1750,14 @@ def test_returns_none_for_all_unconstrained_batch(self) -> None: class TestAssignBitmaskInputs: """Tests for OverlapTextGenerationPipeline._assign_bitmask_inputs. - ``_assign_bitmask_inputs`` either *adopts* the callback's pinned writes - in place when the row layout exactly matches (zero-copy fast path), or - reconciles per-row otherwise: continuing rows are gathered from the - callback's pinned output by request_id (robust to reorder / completion / - growth) and only rows with no FSM state to advance (fresh / reactivated) - are synchronous-filled via ``compute_speculative_bitmasks`` + ``prime``. These - tests cover those branches by mocking the overlap state's - ``get_input_views`` / ``prime`` / ``pinned_bitmask`` / flag. + The method populates model_inputs with the packed bitmask triple + (pinned_view, wait_payload, device_scratch_view) sourced from + ``StructuredOutputOverlapState.get_input_views``. + + Steady state (a callback ran): the async callback enqueued at the head of + execute is the sole writer of the bitmask rectangle, so this method does no + synchronous fill -- it only binds the views. Cold start (no prior callback) + fills every row via ``StructuredOutputOverlapState.prime``. """ _VOCAB = 64 @@ -1481,12 +1770,7 @@ class TestAssignBitmaskInputs: def _make_constrained_ctx( request_id: RequestID, is_initial_prompt: bool = True ) -> TextContext: - """Create a constrained context with ``ctx.matcher`` set, so the - adoption guard's ``ctx.matcher is None`` clause does not fire. - - ``is_initial_prompt=False`` marks a continuing decode row (its row is - gathered from the callback); the default marks a fresh / reactivated - row (synchronous-filled).""" + """Create a constrained context with ``ctx.matcher`` set.""" ctx = TextContext( request_id=request_id, max_length=1000, @@ -1508,27 +1792,29 @@ def _make_pipeline( MagicMock, MagicMock, ]: - """Build a pipeline + spec_state + overlap_state wired with - mocks for the helpers ``_assign_bitmask_inputs`` consumes. + """Build a pipeline + spec_state + overlap_state wired with mocks. Returns ``(pipeline, structured_output, spec_state, - overlap_state, mock_device)``. The mock_device stands in for - ``pipeline._devices[0]`` and is returned separately so each - test can assert that the device's default stream is never - synchronised from this code path (the design contract is - that ``_assign_bitmask_inputs`` runs without ever blocking on - the device). ``overlap_state.get_input_views`` returns a - deterministic pair of sentinel objects so the test can verify - the (pinned, scratch) triple was wired onto ``model_inputs``. + overlap_state, mock_device)``. + + ``callback_request_ids`` identifies which previous-batch request IDs + the async callback wrote; the pipeline wires a ``_prev_batch`` mock + whose ``flat_batch`` has exactly those IDs so ``_assign_bitmask_inputs`` + derives the continuing-row set correctly. + + ``overlap_state.get_input_views(batch_size, num_positions)`` returns + a stable ``(pinned_view, scratch_view)`` pair so tests can assert + identity on ``model_inputs.pinned_bitmask`` and + ``model_inputs.device_bitmask_scratch``. + + ``overlap_state.pinned_bitmask.to_numpy()`` returns a real writeable + numpy array so direct slot writes by the method under test succeed. """ pipeline: OverlapTextGenerationPipeline[TextContext] = ( OverlapTextGenerationPipeline.__new__(OverlapTextGenerationPipeline) ) mock_structured_output = MagicMock() mock_structured_output.enabled = True - # The synchronous fill is called only for the rows the callback did not - # cover; return a packed int32 array (-1 = all bits set = all valid) - # sized to whatever subset it receives. mock_structured_output.compute_speculative_bitmasks.side_effect = ( lambda context_batch, draft_tokens, num_positions: np.full( (len(context_batch), num_positions, cls._PACKED_VOCAB), @@ -1538,37 +1824,52 @@ def _make_pipeline( ) pipeline._structured_output = mock_structured_output + # Real writeable array backing the pinned bitmask so slot writes land. + pinned_backing = np.zeros( + (cls._MAX_BATCH, cls._NUM_POS, cls._PACKED_VOCAB), dtype=np.int32 + ) + pinned_view = MagicMock(name="pinned_view") + scratch_view = MagicMock(name="scratch_view") + mock_overlap_state = MagicMock() mock_overlap_state.num_positions = cls._NUM_POS mock_overlap_state.vocab_size = cls._VOCAB mock_overlap_state.packed_vocab_size = cls._PACKED_VOCAB mock_overlap_state.max_batch_size = cls._MAX_BATCH - # Real packed int32 array so gather can copy callback rows out of pinned. - mock_overlap_state.pinned_bitmask.to_numpy.return_value = np.zeros( - (cls._MAX_BATCH, cls._NUM_POS, cls._PACKED_VOCAB), dtype=np.int32 - ) - # Sentinels so the assertion on ``model_inputs.*`` can compare - # by identity. - pinned_view = MagicMock(name="pinned_view") - scratch_view = MagicMock(name="scratch_view") - wait_payload = MagicMock(name="wait_payload") - mock_overlap_state.wait_payload = wait_payload + mock_overlap_state.pinned_bitmask.to_numpy.return_value = pinned_backing + mock_overlap_state.wait_payload = MagicMock(name="wait_payload") mock_overlap_state.get_input_views.return_value = ( pinned_view, scratch_view, ) mock_spec_state = MagicMock() - mock_spec_state.callback_request_ids = list(callback_request_ids) mock_spec_state.has_precomputed_bitmask = has_precomputed_bitmask mock_spec_state.overlap_state = mock_overlap_state - # Default: no realized drafts -> synchronous fills fall back to draft_tokens_np. - # The MAGIC-desync regression test overrides this with a real array. - mock_spec_state.realized_draft_tokens_host = None pipeline._spec_decode_state = mock_spec_state mock_device = MagicMock() pipeline._devices = [mock_device] + + # Wire _prev_batch so _assign_bitmask_inputs can derive prev_rids + # from self._prev_batch.inputs.flat_batch. Always set a mock (even for + # an empty producing batch) when has_precomputed_bitmask=True, because + # the steady-state branch asserts _prev_batch is not None. + if has_precomputed_bitmask: + mock_prev_batch = MagicMock() + prev_contexts = [ + TextContext( + request_id=rid, + max_length=100, + tokens=TokenBuffer(np.array([1])), + ) + for rid in callback_request_ids + ] + mock_prev_batch.inputs.flat_batch = prev_contexts + pipeline._prev_batch = mock_prev_batch + else: + pipeline._prev_batch = None + return ( pipeline, mock_structured_output, @@ -1577,17 +1878,20 @@ def _make_pipeline( mock_device, ) - def test_adopts_callback_when_request_ids_match(self) -> None: - """When the callback's row order matches and every context has a - matcher, ``_assign_bitmask_inputs`` reuses the pinned writes: - ``prime`` is not called and the device default stream is never - synchronised (it never is, on any branch). - ``has_precomputed_bitmask`` is cleared because the callback's - writes have been consumed.""" + def test_steady_state_does_no_synchronous_fill(self) -> None: + """Steady state (a callback ran, ``has_precomputed_bitmask=True``): the + callback is the sole writer of the rectangle, so this method performs no + synchronous bitmask fill -- neither ``prime`` nor + ``compute_speculative_bitmasks`` is called -- and only binds the views. + + This holds for every continuing row in the batch (the only rows that can + appear when a callback ran: the callback is gated on the whole batch + verifying drafts, and the scheduler routes fresh/resumed requests + through the cold-start path instead).""" rid_a = RequestID("a") rid_b = RequestID("b") - ctx_a = self._make_constrained_ctx(rid_a) - ctx_b = self._make_constrained_ctx(rid_b) + ctx_a = self._make_constrained_ctx(rid_a, is_initial_prompt=False) + ctx_b = self._make_constrained_ctx(rid_b, is_initial_prompt=False) pipeline, structured_output, spec_state, overlap_state, mock_device = ( self._make_pipeline( @@ -1609,86 +1913,22 @@ def test_adopts_callback_when_request_ids_match(self) -> None: overlap_state.prime.assert_not_called() mock_device.default_stream.synchronize.assert_not_called() assert spec_state.has_precomputed_bitmask is False + # Views from get_input_views are wired to model_inputs. overlap_state.get_input_views.assert_called_once_with(2, self._NUM_POS) pinned_view, scratch_view = overlap_state.get_input_views.return_value assert model_inputs.pinned_bitmask is pinned_view assert model_inputs.device_bitmask_scratch is scratch_view assert model_inputs.wait_payload is overlap_state.wait_payload - - def test_sync_prime_when_request_ids_reordered(self) -> None: - """When the callback batch was ``[a, b]`` but the current batch - is ``[b, a]``, the row layout no longer matches; overwrite via - ``prime``. The device default stream must not be synchronised - (this code path is contractually drain-free).""" - rid_a = RequestID("a") - rid_b = RequestID("b") - ctx_a = self._make_constrained_ctx(rid_a) - ctx_b = self._make_constrained_ctx(rid_b) - - pipeline, structured_output, spec_state, overlap_state, mock_device = ( - self._make_pipeline( - callback_request_ids=[rid_a, rid_b], - has_precomputed_bitmask=True, - ) - ) - - pipeline._assign_bitmask_inputs( - model_inputs=MagicMock(), - context_batch=[ctx_b, ctx_a], - draft_tokens_np=np.zeros((2, self._K), dtype=np.int64), - num_draft_tokens_to_verify=self._K, - ) - - mock_device.default_stream.synchronize.assert_not_called() - structured_output.compute_speculative_bitmasks.assert_called_once() - overlap_state.prime.assert_called_once() - assert spec_state.has_precomputed_bitmask is False - - def test_sync_prime_when_some_context_missing_matcher(self) -> None: - """A new context that joined this iter has ``matcher is None`` - but a grammar / schema set -- the adoption guard rejects this - case because the FSM for the joining context hasn't been - initialised, so the callback's bitmask is stale for that row. - Must fall through to the sync-prime path.""" - rid_a = RequestID("a") - rid_b = RequestID("b") - ctx_a = self._make_constrained_ctx(rid_a) - # ctx_b has grammar set but no matcher yet (just joined). - ctx_b = TextContext( - request_id=rid_b, - max_length=1000, - tokens=TokenBuffer(np.array([1, 2, 3])), - grammar="root ::= 'x'", - ) - assert ctx_b.matcher is None and ctx_b.grammar is not None - - ( - pipeline, - structured_output, - _spec_state, - overlap_state, - mock_device, - ) = self._make_pipeline( - callback_request_ids=[rid_a, rid_b], - has_precomputed_bitmask=True, - ) - - pipeline._assign_bitmask_inputs( - model_inputs=MagicMock(), - context_batch=[ctx_a, ctx_b], - draft_tokens_np=np.zeros((2, self._K), dtype=np.int64), - num_draft_tokens_to_verify=self._K, + # No row_map attribute (the old gather is gone). + assert ( + not hasattr(model_inputs, "row_map") + or model_inputs.row_map != overlap_state ) - mock_device.default_stream.synchronize.assert_not_called() - structured_output.compute_speculative_bitmasks.assert_called_once() - overlap_state.prime.assert_called_once() - - def test_sync_prime_when_no_callback_at_all(self) -> None: - """Cold start (e.g. prefill -> first decode): no callback was - enqueued at the prior iter, so ``has_precomputed_bitmask`` is - ``False``. ``prime`` runs; the default stream is not - synchronised (this code path is contractually drain-free).""" + def test_cold_start_calls_prime_with_full_batch_bitmask(self) -> None: + """Cold start (prefill -> first decode, ``has_precomputed_bitmask`` + False): compute every row synchronously then call ``prime`` so the + in-graph flag wait passes immediately.""" rid_a = RequestID("a") ctx_a = self._make_constrained_ctx(rid_a) @@ -1709,333 +1949,32 @@ def test_sync_prime_when_no_callback_at_all(self) -> None: mock_device.default_stream.synchronize.assert_not_called() structured_output.compute_speculative_bitmasks.assert_called_once() overlap_state.prime.assert_called_once() - # Flag is not toggled by ``_assign_bitmask_inputs`` itself when - # there was no callback to consume. assert spec_state.has_precomputed_bitmask is False - def test_sync_prime_when_composition_changed_with_all_matchers( - self, - ) -> None: - """Composition change with every ctx already holding a matcher - still falls into sync-prime: ``callback_request_ids == - current_request_ids`` is False, which short-circuits the - adoption guard before the matcher check runs. Verifies the - pure-composition-change branch independent of the - ``ctx.matcher is None`` clause.""" - rid_a, rid_b, rid_c = ( - RequestID("a"), - RequestID("b"), - RequestID("c"), - ) - ctx_a = self._make_constrained_ctx(rid_a) - ctx_b = self._make_constrained_ctx(rid_b) - ctx_c = self._make_constrained_ctx(rid_c) - - pipeline, structured_output, _spec_state, overlap_state, mock_device = ( - self._make_pipeline( - # Callback wrote rows for [a, b]; iter-N+1 adds c. - callback_request_ids=[rid_a, rid_b], - has_precomputed_bitmask=True, - ) - ) - - pipeline._assign_bitmask_inputs( - model_inputs=MagicMock(), - context_batch=[ctx_a, ctx_b, ctx_c], - draft_tokens_np=np.zeros((3, self._K), dtype=np.int64), - num_draft_tokens_to_verify=self._K, - ) - - mock_device.default_stream.synchronize.assert_not_called() - structured_output.compute_speculative_bitmasks.assert_called_once() - overlap_state.prime.assert_called_once() - - def test_sync_prime_when_callback_ids_disjoint_from_current(self) -> None: - """All callback rows belong to evicted requests; iter-N+1's - batch is entirely fresh. Equivalent to the deleted - ``test_all_missing_falls_back_to_full_sync`` -- there is - nothing to adopt, so every row is sync-primed. The default - stream is never synchronised.""" - ctx_fresh = self._make_constrained_ctx(RequestID("fresh")) - - pipeline, structured_output, _spec_state, overlap_state, mock_device = ( - self._make_pipeline( - callback_request_ids=[RequestID("evicted")], - has_precomputed_bitmask=True, - ) - ) - - pipeline._assign_bitmask_inputs( - model_inputs=MagicMock(), - context_batch=[ctx_fresh], - draft_tokens_np=np.zeros((1, self._K), dtype=np.int64), - num_draft_tokens_to_verify=self._K, - ) - - mock_device.default_stream.synchronize.assert_not_called() - structured_output.compute_speculative_bitmasks.assert_called_once() - overlap_state.prime.assert_called_once() - - def test_sync_prime_passes_only_new_rows_to_compute(self) -> None: - """Gather-by-rid only synchronous-fills rows the callback did not cover: - a continuing row (``a``) is gathered from the callback's pinned - output, while a freshly joined row (``b``) is the only row passed to - ``compute_speculative_bitmasks``.""" - rid_a, rid_b = RequestID("a"), RequestID("b") + def test_get_input_views_always_wired_to_model_inputs(self) -> None: + """``model_inputs.pinned_bitmask`` and + ``model_inputs.device_bitmask_scratch`` are the views returned by + ``get_input_views``, regardless of branch.""" + rid_a = RequestID("a") ctx_a = self._make_constrained_ctx(rid_a, is_initial_prompt=False) - ctx_b = self._make_constrained_ctx(rid_b) # fresh -> synchronous-filled - - pipeline, structured_output, _spec_state, _overlap_state, _ = ( - self._make_pipeline( - callback_request_ids=[rid_a], # b is "missing". - has_precomputed_bitmask=True, - ) - ) - - pipeline._assign_bitmask_inputs( - model_inputs=MagicMock(), - context_batch=[ctx_a, ctx_b], - draft_tokens_np=np.zeros((2, self._K), dtype=np.int64), - num_draft_tokens_to_verify=self._K, - ) - - call_kwargs = ( - structured_output.compute_speculative_bitmasks.call_args.kwargs - ) - # Only the new row, not the gathered continuing row. - assert call_kwargs["context_batch"] == [ctx_b] - # Bitmask shape is keyed on overlap_state.num_positions (the - # captured-graph dim), not on num_draft_tokens_to_verify. - assert call_kwargs["num_positions"] == self._NUM_POS - - def test_sync_prime_waits_for_unset_callback_event_then_clears( - self, - ) -> None: - """On the sync-prime branch, an in-flight callback's done_event - is awaited *before* ``prime`` overwrites pinned, then cleared to - ``None`` so a subsequent callback-less iter doesn't re-wait on - the consumed event.""" - ctx_a = self._make_constrained_ctx(RequestID("a")) - pipeline, _structured_output, spec_state, overlap_state, _ = ( - self._make_pipeline( - callback_request_ids=[], - has_precomputed_bitmask=False, - ) - ) - - mock_event = MagicMock(name="done_event") - mock_event.is_set.return_value = False - - # Worker finished within the timeout. Assert the wait happens - # before ``prime`` so a late worker write can't stomp primed rows. - def _wait(timeout: float) -> bool: - assert not overlap_state.prime.called, ( - "prime ran before waiting on the callback done_event" - ) - return True - - mock_event.wait.side_effect = _wait - spec_state.last_callback_done_event = mock_event - - pipeline._assign_bitmask_inputs( - model_inputs=MagicMock(), - context_batch=[ctx_a], - draft_tokens_np=np.zeros((1, self._K), dtype=np.int64), - num_draft_tokens_to_verify=self._K, - ) - - mock_event.wait.assert_called_once_with(timeout=_CALLBACK_LAG_WARN_S) - overlap_state.prime.assert_called_once() - assert spec_state.last_callback_done_event is None - - def test_sync_prime_skips_wait_when_callback_event_already_set( - self, - ) -> None: - """If the prior callback already signalled completion, the - sync-prime branch skips ``wait()`` entirely but still clears the - consumed event.""" - ctx_a = self._make_constrained_ctx(RequestID("a")) - pipeline, _structured_output, spec_state, overlap_state, _ = ( - self._make_pipeline( - callback_request_ids=[], - has_precomputed_bitmask=False, - ) - ) - - mock_event = MagicMock(name="done_event") - mock_event.is_set.return_value = True - spec_state.last_callback_done_event = mock_event - - pipeline._assign_bitmask_inputs( - model_inputs=MagicMock(), - context_batch=[ctx_a], - draft_tokens_np=np.zeros((1, self._K), dtype=np.int64), - num_draft_tokens_to_verify=self._K, - ) - - mock_event.wait.assert_not_called() - overlap_state.prime.assert_called_once() - assert spec_state.last_callback_done_event is None - - def test_sync_prime_logs_and_proceeds_when_callback_event_times_out( - self, - ) -> None: - """A worker that never ran never sets the event. We keep waiting - through the 5s lag warning, then proceed at the 120s deadline with - an error log (degrade to a noisy race, not a silent hang) -- and the - consumed event is still cleared.""" - ctx_a = self._make_constrained_ctx(RequestID("a")) - pipeline, _structured_output, spec_state, overlap_state, _ = ( - self._make_pipeline( - callback_request_ids=[], - has_precomputed_bitmask=False, - ) - ) - - mock_event = MagicMock(name="done_event") - mock_event.is_set.return_value = False - mock_event.wait.return_value = False # never signaled - spec_state.last_callback_done_event = mock_event - - with patch( - "max.pipelines.lib.pipeline_variants.overlap_text_generation.logger" - ) as mock_logger: - pipeline._assign_bitmask_inputs( - model_inputs=MagicMock(), - context_batch=[ctx_a], - draft_tokens_np=np.zeros((1, self._K), dtype=np.int64), - num_draft_tokens_to_verify=self._K, - ) - # Two-tier wait: warn at 5s, then wait out the rest of the 120s deadline. - assert mock_event.wait.call_count == 2 - mock_event.wait.assert_any_call(timeout=5.0) - mock_event.wait.assert_any_call(timeout=115.0) - mock_logger.warning.assert_called_once() - mock_logger.error.assert_called_once() - overlap_state.prime.assert_called_once() - assert spec_state.last_callback_done_event is None - - def test_adopt_path_leaves_callback_event_uncleared(self) -> None: - """The clear-to-``None`` lives inside the sync-prime branch. On - the adopt path (``can_adopt`` true, ``prime`` skipped) the event - is intentionally left as-is: ``prime`` is never called there, so - there is nothing to re-wait on. Locks the subtlety that - ``last_callback_done_event`` is *not* an - ``in-flight-iff-non-None`` flag.""" - rid_a = RequestID("a") - ctx_a = self._make_constrained_ctx(rid_a) - pipeline, structured_output, spec_state, overlap_state, _ = ( - self._make_pipeline( - callback_request_ids=[rid_a], - has_precomputed_bitmask=True, - ) + pipeline, _, _, overlap_state, _ = self._make_pipeline( + callback_request_ids=[rid_a], + has_precomputed_bitmask=True, ) - mock_event = MagicMock(name="done_event") - mock_event.is_set.return_value = True - spec_state.last_callback_done_event = mock_event - + model_inputs = MagicMock() pipeline._assign_bitmask_inputs( - model_inputs=MagicMock(), + model_inputs=model_inputs, context_batch=[ctx_a], draft_tokens_np=np.zeros((1, self._K), dtype=np.int64), num_draft_tokens_to_verify=self._K, ) - structured_output.compute_speculative_bitmasks.assert_not_called() - overlap_state.prime.assert_not_called() - mock_event.wait.assert_not_called() - assert spec_state.last_callback_done_event is mock_event - - def test_reorder_gathers_continuing_rows_without_recompute(self) -> None: - """A pure reorder of continuing rows adopts each request's callback - row by id (gathered into its new position); the FSM is never - re-walked, so ``compute_speculative_bitmasks`` is not called.""" - rid_a, rid_b = RequestID("a"), RequestID("b") - ctx_a = self._make_constrained_ctx(rid_a, is_initial_prompt=False) - ctx_b = self._make_constrained_ctx(rid_b, is_initial_prompt=False) - - pipeline, structured_output, _spec_state, overlap_state, _ = ( - self._make_pipeline( - callback_request_ids=[rid_a, rid_b], - has_precomputed_bitmask=True, - ) - ) - # Mark the callback's rows so the gather can be verified by value. - pinned = overlap_state.pinned_bitmask.to_numpy.return_value - pinned[0, :, 0] = True # a's row - pinned[1, :, 1] = True # b's row - - pipeline._assign_bitmask_inputs( - model_inputs=MagicMock(), - context_batch=[ctx_b, ctx_a], # reordered - draft_tokens_np=np.zeros((2, self._K), dtype=np.int64), - num_draft_tokens_to_verify=self._K, - ) - - structured_output.compute_speculative_bitmasks.assert_not_called() - overlap_state.prime.assert_called_once() - assembled = overlap_state.prime.call_args.args[0] - # Row 0 is b's callback row, row 1 is a's -- gathered into new order. - assert np.array_equal(assembled[0], pinned[1]) - assert np.array_equal(assembled[1], pinned[0]) - - # ----- direct _gather_bitmask tests ------------------------------------- - - def test_gather_bitmask_gathers_continuing_and_sync_fills_new(self) -> None: - """A continuing row adopts its callback row by id; a freshly joined - row (not in the callback batch) is the only row synchronous-filled.""" - rid_a, rid_c = RequestID("a"), RequestID("c") - ctx_a = self._make_constrained_ctx(rid_a, is_initial_prompt=False) - ctx_c = self._make_constrained_ctx(rid_c) # fresh (initial) -> sync - - pipeline, structured_output, _s, overlap_state, _d = ( - self._make_pipeline( - callback_request_ids=[rid_a], has_precomputed_bitmask=True - ) - ) - pinned = overlap_state.pinned_bitmask.to_numpy.return_value - pinned[0, :, 0] = True # a's distinctive callback row - - assembled = pipeline._gather_bitmask( - [ctx_a, ctx_c], - [rid_a], - np.zeros((2, self._K), dtype=np.int64), - self._NUM_POS, - ) - - assert np.array_equal(assembled[0], pinned[0]) # a gathered - assert assembled[1].all() # c synchronous-filled (compute -> all True) - call = structured_output.compute_speculative_bitmasks.call_args - assert call.kwargs["context_batch"] == [ctx_c] - - def test_gather_bitmask_reorders_rows_by_request_id(self) -> None: - """Reordered continuing rows each adopt their own callback row.""" - rid_a, rid_b = RequestID("a"), RequestID("b") - ctx_a = self._make_constrained_ctx(rid_a, is_initial_prompt=False) - ctx_b = self._make_constrained_ctx(rid_b, is_initial_prompt=False) - - pipeline, structured_output, _s, overlap_state, _d = ( - self._make_pipeline( - callback_request_ids=[rid_a, rid_b], - has_precomputed_bitmask=True, - ) - ) - pinned = overlap_state.pinned_bitmask.to_numpy.return_value - pinned[0, :, 0] = True # a - pinned[1, :, 1] = True # b - - assembled = pipeline._gather_bitmask( - [ctx_b, ctx_a], # reordered - [rid_a, rid_b], - np.zeros((2, self._K), dtype=np.int64), - self._NUM_POS, - ) - - structured_output.compute_speculative_bitmasks.assert_not_called() - assert np.array_equal(assembled[0], pinned[1]) # b - assert np.array_equal(assembled[1], pinned[0]) # a + pinned_view, scratch_view = overlap_state.get_input_views.return_value + assert model_inputs.pinned_bitmask is pinned_view + assert model_inputs.device_bitmask_scratch is scratch_view + assert model_inputs.wait_payload is overlap_state.wait_payload def test_sync_fill_uses_realized_drafts_not_magic(self) -> None: """Synchronous-fill must build the speculative bitmask from realized drafts. @@ -2054,9 +1993,10 @@ def test_sync_fill_uses_realized_drafts_not_magic(self) -> None: The realized host drafts are gathered through the same prev->curr scatter map ``realize_future_tokens`` uses (a pure row permutation of - ``prev_batch.next_draft_tokens_host``) and exposed on - ``spec_state.realized_draft_tokens_host``. The synchronous fill must feed - those to ``compute_speculative_bitmasks`` instead. + ``prev_batch.next_draft_tokens_host``) and passed as + ``realized_draft_tokens_host`` to ``_assign_bitmask_inputs``. The + synchronous fill must feed those to ``compute_speculative_bitmasks`` + instead. Contract asserted: the ``draft_tokens`` handed to ``compute_speculative_bitmasks`` on the synchronous-fill path equal the @@ -2065,7 +2005,7 @@ def test_sync_fill_uses_realized_drafts_not_magic(self) -> None: rid_a = RequestID("a") ctx_a = self._make_constrained_ctx(rid_a, is_initial_prompt=False) - pipeline, structured_output, spec_state, _overlap_state, _ = ( + pipeline, structured_output, _spec_state, _overlap_state, _ = ( self._make_pipeline( callback_request_ids=[], # cold start: no callback rows has_precomputed_bitmask=False, # -> whole-batch synchronous fill @@ -2083,13 +2023,13 @@ def test_sync_fill_uses_realized_drafts_not_magic(self) -> None: # buffer for this row, made host-visible through the shared map. realized_drafts = np.array([[7, 9]], dtype=np.int64) assert not np.array_equal(realized_drafts, magic_drafts) - spec_state.realized_draft_tokens_host = realized_drafts pipeline._assign_bitmask_inputs( model_inputs=MagicMock(), context_batch=[ctx_a], draft_tokens_np=magic_drafts, num_draft_tokens_to_verify=self._K, + realized_draft_tokens_host=realized_drafts, ) structured_output.compute_speculative_bitmasks.assert_called_once() diff --git a/max/tests/integration/pipelines/text_generation_pipeline/test_overlap_text_generation_pipeline_gpu.py b/max/tests/integration/pipelines/text_generation_pipeline/test_overlap_text_generation_pipeline_gpu.py index fa69cde8e6d..db1b2aff362 100644 --- a/max/tests/integration/pipelines/text_generation_pipeline/test_overlap_text_generation_pipeline_gpu.py +++ b/max/tests/integration/pipelines/text_generation_pipeline/test_overlap_text_generation_pipeline_gpu.py @@ -405,7 +405,7 @@ def create_overlap_pipeline( pipeline_model=cast(type[PipelineModel[Any]], FakePipelineModel), eos_token_id=9999, weight_adapters=MagicMock(), - tokenizer=MagicMock(), + tokenizer=MagicMock(spec=[]), disable_overlap=disable_overlap, ) return pipeline From 20279a7467273d95519199fca00198ffa6b8d7d8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thomas=20B=C3=B8rstad?= <4872288+tboerstad@users.noreply.github.com> Date: Sun, 21 Jun 2026 21:04:39 +0200 Subject: [PATCH 2/4] [CI] Exclude gemma-3 bfloat16 models from MI355 post-submit Skip gemma-3 1b and 12b from smoke tests and/or logit verification. They're crashing due to an upstream LLVM/AMD backend issue. MODULAR_ORIG_COMMIT_REV_ID: 065f82387aed5f1c3d9dbb08d6db23c3133442fb --- .../accuracy/logit_verification/logit_verification_config.yaml | 3 ++- .../accuracy/smoke_tests/smoke_test_github_matrix.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/max/tests/integration/accuracy/logit_verification/logit_verification_config.yaml b/max/tests/integration/accuracy/logit_verification/logit_verification_config.yaml index 93ce35488db..6bd5cffeec8 100644 --- a/max/tests/integration/accuracy/logit_verification/logit_verification_config.yaml +++ b/max/tests/integration/accuracy/logit_verification/logit_verification_config.yaml @@ -932,6 +932,7 @@ logit_verification_pipelines: pipeline: "google/gemma-3-1b-it" compatible_with: [gpu] encoding: bfloat16 + tags: [nvidia-only] # TODO(KERN-3014): AMD MI355 compile crash. pregenerated_torch_goldens: tar_file: "s3://modular-bazel-artifacts-public/artifacts/torch_gemma3-1b_golden/1/31d4f0ff8f50b9ab0f877d8765114f6bc4ae73677d2cd2d6ce658866fabf15d4/torch_gemma3-1b_golden.tar.gz" json_file: "torch_gemma3-1b_bfloat16_golden.json" @@ -943,7 +944,7 @@ logit_verification_pipelines: pipeline: "google/gemma-3-12b-it" compatible_with: [gpu] encoding: bfloat16 - tags: [] + tags: [nvidia-only] # TODO(KERN-3014): AMD MI355 compile crash. pregenerated_torch_goldens: tar_file: "s3://modular-bazel-artifacts-public/artifacts/torch_gemma3-multimodal_golden/1/06d0fa8ed540ae7141a42c432af1661c85d31f8584d017345992df7a52c21ccb/torch_gemma3-multimodal_golden.tar.gz" json_file: "torch_gemma3-multimodal_bfloat16_golden.json" diff --git a/max/tests/integration/accuracy/smoke_tests/smoke_test_github_matrix.py b/max/tests/integration/accuracy/smoke_tests/smoke_test_github_matrix.py index 6a3b7552a50..a2648b2a672 100644 --- a/max/tests/integration/accuracy/smoke_tests/smoke_test_github_matrix.py +++ b/max/tests/integration/accuracy/smoke_tests/smoke_test_github_matrix.py @@ -75,7 +75,7 @@ "deepseek-ai/DeepSeek-V2-Lite-Chat": MULTI | {"max", "max-ci", "vllm@B200"}, # SERVOPT-1120 "deepseek-ai/DeepSeek-V3.1-Terminus": NON_XL | {"4xMI355"}, "google/diffusiongemma-26B-A4B-it": MULTI | {"max", "max-ci"}, - "google/gemma-3-1b-it": MULTI | {"vllm@B200"}, + "google/gemma-3-1b-it": MULTI | {"vllm@B200", "MI355"}, # TODO(KERN-3014) "google/gemma-3-27b-it": MULTI, "google/gemma-4-26B-A4B-it": MULTI | {"max", "max-ci"}, # TODO(SERVOPT-1292) "google/gemma-4-31B-it": MULTI, From c014b6a6af70592ca5d0b298d995272477a67892 Mon Sep 17 00:00:00 2001 From: Sriram Govindan <62492215+govindansriram@users.noreply.github.com> Date: Sun, 21 Jun 2026 20:25:10 -0700 Subject: [PATCH 3/4] [kernels] stage B in registers and interleave MFMA with stores (#89120) We currently have A staged in registers and we rotate through B when doing MFMA, this code switches it. This saves on registers decreasing pressure. It also offers a slight performance boost. We also changed the ordering of the MFMA, to allow for interleaved B stores with MFMA calls. MODULAR_ORIG_COMMIT_REV_ID: bb826331c0c02baf47af56d83ee9d4c702844aba --- .../gpu/linalg/bench_grouped_matmul_amd.mojo | 70 ++- .../gpu/amd/mxfp4_grouped_matmul_amd.mojo | 18 +- .../matmul/gpu/amd/mxfp4_matmul_amd_preb.mojo | 124 ++++-- ...test_mxfp4_grouped_matmul_amd_kernels.mojo | 418 ++++++++++++++---- 4 files changed, 466 insertions(+), 164 deletions(-) diff --git a/max/kernels/benchmarks/gpu/linalg/bench_grouped_matmul_amd.mojo b/max/kernels/benchmarks/gpu/linalg/bench_grouped_matmul_amd.mojo index bd209138807..0de2c285b6b 100644 --- a/max/kernels/benchmarks/gpu/linalg/bench_grouped_matmul_amd.mojo +++ b/max/kernels/benchmarks/gpu/linalg/bench_grouped_matmul_amd.mojo @@ -23,6 +23,7 @@ preshuffled B, direct VGPR loads). from std.math import align_up, ceildiv from std.os import abort +from std.random import random_ui64, seed from std.sys import ( get_defined_int, get_defined_string, @@ -317,6 +318,11 @@ def main() raises: var num_active_experts = Int(arg_parse("num_active_experts", 1)) var M = Int(arg_parse("M", 256)) + # Expert-parallel degree: experts are sharded across this many GPUs, so a + # token's `topk` global picks land on this rank's local shard only ~1/N of + # the time. Per-rank routed-M = M * topk // n_gpus_per_node, matching + # `nn/moe/expert_parallel.py` (total_tokens * topk // n_gpus_per_node). + var n_gpus_per_node = Int(arg_parse("n_gpus_per_node", 4)) var skew_spec = String(arg_parse("expert_skew", "uniform")) var init_type = InitializationType.from_str( arg_parse("init_type", "uniform_distribution") @@ -356,18 +362,43 @@ def main() raises: var have_counts = target_counts_csv.byte_length() != 0 var have_ids = expert_ids_csv.byte_length() != 0 if not have_counts and not have_ids: - # Synthesize uniform routing from M (per-GPU routed token-rows): spread - # M rows over min(M, num_experts) experts as evenly as possible. Lets a - # decode bench sweep M alone (e.g. `$M: "range(1, 257)"`) with no - # literal per-expert lists. - var rows = M if M > 0 else 1 - var active = min(rows, num_experts) - var base = rows // active - var rem = rows % active - for i in range(active): - target_counts.append((base + 1) if i < rem else base) - expert_id_pool.append(i) - num_active_experts = active + # Synthesize realistic EP-sharded MoE routing. Each of `M` tokens routes + # to `topk` distinct experts out of the GLOBAL pool + # (num_experts * n_gpus_per_node); only picks landing on THIS rank's + # local shard ([0, num_experts)) are processed here. So per-rank routed + # rows ~= M * topk // n_gpus_per_node, matching + # `nn/moe/expert_parallel.py` (total_tokens * topk // n_gpus_per_node), + # and active experts follow coupon-collector over the local shard. + # n_gpus_per_node=1 reduces to a single-GPU run (all picks local). + # `seed(0)` keeps the routing reproducible across runs. + seed(0) + var num_tokens = M if M > 0 else 1 + var gpus = max(n_gpus_per_node, 1) + var global_experts = num_experts * gpus + var k = min(topk, global_experts) + var counts = List[Int]() + for _ in range(num_experts): + counts.append(0) + for _ in range(num_tokens): + var picks = List[Int]() + while len(picks) < k: + var e = Int(random_ui64(0, UInt64(global_experts - 1))) + var dup = False + for i in range(len(picks)): + if picks[i] == e: + dup = True + break + if not dup: + picks.append(e) + # Count only picks that land on this rank's local shard. + for i in range(len(picks)): + if picks[i] < num_experts: + counts[picks[i]] += 1 + for e in range(num_experts): + if counts[e] > 0: + target_counts.append(counts[e]) + expert_id_pool.append(e) + num_active_experts = len(target_counts) elif not have_counts or not have_ids: abort( "target_counts and expert_ids must be set together, or both" @@ -413,6 +444,8 @@ def main() raises: M, " topk=", topk, + " n_gpus_per_node=", + n_gpus_per_node, " N=", N, " K=", @@ -432,13 +465,12 @@ def main() raises: with DeviceContext() as ctx: var bench = Bench() - # target_counts are per-GPU local expert token-rows (EP already - # applied), so their sum IS the per-rank routed M that production's - # `total_tokens * topk // n_gpus_per_node` yields. Drives the preb - # dispatcher's persistent-vs-direct switch. - var estimated_total_m = 0 - for c in target_counts: - estimated_total_m += c + # `estimated_total_m` drives the preb dispatcher's band + + # persistent-vs-direct switch. Production computes it from the routing + # FORMULA (an estimate available at dispatch time), not the exact + # per-expert counts — see nn/moe/expert_parallel.py: + # estimated_total_m = total_tokens * topk // n_gpus_per_node + var estimated_total_m = M * topk // max(n_gpus_per_node, 1) bench_preb[ num_experts=num_experts, N=N, diff --git a/max/kernels/src/linalg/matmul/gpu/amd/mxfp4_grouped_matmul_amd.mojo b/max/kernels/src/linalg/matmul/gpu/amd/mxfp4_grouped_matmul_amd.mojo index ffeecbc0b4c..835f56627d9 100644 --- a/max/kernels/src/linalg/matmul/gpu/amd/mxfp4_grouped_matmul_amd.mojo +++ b/max/kernels/src/linalg/matmul/gpu/amd/mxfp4_grouped_matmul_amd.mojo @@ -28,12 +28,6 @@ from std.utils import StaticTuple from .mxfp4_matmul_amd import MXFP4MatmulAMD as _MXFP4MatmulAMD from .mxfp4_matmul_amd_preb import MXFP4MatmulAMD_PreB as _MXFP4MatmulAMD_PreB -# Preb perf knobs (b_cache_policy / dram_to_lds / cluster_drain_sched / -# mfma_cluster / deep_prime) are per-launch comptime params on `launch[...]`, -# defaulted to current behavior — tune them per (N, K, M-band) in the dispatch -# branches, same as the tile config. kbench: cluster_drain_sched regressed -7.9% -# globally, so leave it off unless a specific band shows a win. - @always_inline def _waves_per_eu_attr[waves_per_eu: Int]() -> __mlir_type.`!kgen.string`: @@ -959,11 +953,15 @@ def mxfp4_grouped_matmul_amd_preb( elif etm <= 1023: return run_kernel[16, 128, 512, 32, True, STREAM]() elif etm <= 2047: - return run_kernel[32, 128, 512, 32, True, STREAM]() - elif etm <= 4095: - return run_kernel[64, 128, 512, 64, True, STREAM]() + return run_kernel[32, 128, 512, 32, True]() + elif etm <= 3072: + return run_kernel[64, 128, 512, 64, True]() + elif etm <= 6144: + return run_kernel[128, 128, 512, 64, True]() + elif etm <= 9216: + return run_kernel[64, 128, 512, 64, True, deep_prime=True]() else: - return run_kernel[64, 128, 256, 64, False]() + return run_kernel[64, 128, 512, 64, False, deep_prime=True]() # Other shapes: persistent below the threshold, direct at/above it. if etm >= m_threshold: diff --git a/max/kernels/src/linalg/matmul/gpu/amd/mxfp4_matmul_amd_preb.mojo b/max/kernels/src/linalg/matmul/gpu/amd/mxfp4_matmul_amd_preb.mojo index adc8c8f1fa9..608bb976266 100644 --- a/max/kernels/src/linalg/matmul/gpu/amd/mxfp4_matmul_amd_preb.mojo +++ b/max/kernels/src/linalg/matmul/gpu/amd/mxfp4_matmul_amd_preb.mojo @@ -378,20 +378,19 @@ struct BlockScaledMmaOp_PreB[ @always_inline def mma[mma_k_idx: Int, slot: Int = 0](self): - """Execute block-scaled MFMA at MFMA-K position `mma_k_idx` using B from `slot`. + """Block-scaled MFMA at MFMA-K position `mma_k_idx` using B from `slot`. - B→src_a, A→src_b (AMD MFMA convention). + B-major / n-outer / m-inner: hoist the B fragment + b_byte + b_scale + (VMEM-loaded `_b_reg`) once per n, then cycle A (m-inner, LDS-loaded + `_a_reg`). Keeping B resident across the m-loop improves MFMA ILP. - OPSEL byte selection picks the right byte from the 2x2 cell: + OPSEL byte selection from the 2x2 cell: a_byte = (mma_k_idx % 2) * 2 + (m % 2) b_byte = (mma_k_idx % 2) * 2 + (n % 2) - Scale dword lives at `_*_scale_packed[mn // 2, mma_k_idx // 2]`. - - WM=16 / WN=16 case: every CTA only ever sees `m=0` / `n=0`, so - OPSEL is fixed at byte 0 (or 2 for k_pack=1). The constructor - records a `shrui` amount (`_a_scale_shift` / `_b_scale_shift`) - that rotates the i32 right by 0 or 8 bits so the byte OPSEL - selects is the one for this CTA's half of the cell. + Scale dword lives at `_*_scale_packed[mn // 2, mma_k_idx // 2]`. WM/WN=16 + CTAs see only m=0 / n=0, so the constructor `shrui` + (`_a_scale_shift` / `_b_scale_shift`) rotates the i32 to the right OPSEL + byte. """ comptime assert slot < Self.num_b_slots, "slot out of range" var a_reg_v = self._a_reg.vectorize[1, 1, Self.mma_frag_width_bytes]() @@ -400,32 +399,31 @@ struct BlockScaledMmaOp_PreB[ ]() var c_reg_v = self._c_reg.vectorize[1, Self.c_frag_size]() - comptime for m in range(Self.num_m_mmas): - # A-side state — invariant across the inner n loop. The - # cdna4_block_scaled_mfma wrapper expects A/B fragments - # sized to FLOAT4_E2M1.simd_width() = 16 — pass the 16-byte - # `*_data` lanes directly (do NOT pad to 32). - var a_frag = a_reg_v[mma_k_idx, m, 0] + # 2x2 (k_pack × mn_pack) cell -> OPSEL byte: (k%2, mn%2) row-major. + comptime scale_cell = row_major[2, 2]() - comptime a_byte = (mma_k_idx % 2) * 2 + (m % 2) - var a_scale = rebind[Int32]( - self._a_scale_packed[m // 2, mma_k_idx // 2] - ) + comptime for n in range(Self.num_n_mmas): + # B-side state — invariant across the inner m loop. + var b_frag = b_reg_v[slot, mma_k_idx, n, 0] - comptime if Self.warp_tile[0] == 16: - a_scale = Int32(UInt32(a_scale) >> self._a_scale_shift) + comptime b_byte = (mma_k_idx % 2) * 2 + (n % 2) + var b_scale = rebind[Int32]( + self._b_scale_packed[n // 2, mma_k_idx // 2] + ) + comptime if Self.warp_tile[1] == 16: + b_scale = Int32(UInt32(b_scale) >> self._b_scale_shift) - comptime for n in range(Self.num_n_mmas): - var b_frag = b_reg_v[slot, mma_k_idx, n, 0] + comptime for m in range(Self.num_m_mmas): + var a_frag = a_reg_v[mma_k_idx, m, 0] var c_frag = c_reg_v[m, n] - comptime b_byte = (mma_k_idx % 2) * 2 + (n % 2) - var b_scale = rebind[Int32]( - self._b_scale_packed[n // 2, mma_k_idx // 2] + comptime a_byte = (mma_k_idx % 2) * 2 + (m % 2) + var a_scale = rebind[Int32]( + self._a_scale_packed[m // 2, mma_k_idx // 2] ) - comptime if Self.warp_tile[1] == 16: - b_scale = Int32(UInt32(b_scale) >> self._b_scale_shift) + comptime if Self.warp_tile[0] == 16: + a_scale = Int32(UInt32(a_scale) >> self._a_scale_shift) cdna4_block_scaled_mfma[ Int32(b_byte), @@ -467,11 +465,14 @@ struct MXFP4MatmulAMD_PreB[ K-heavy shapes (e.g. gate/up, K=7168) where outer-iter serialization dominates. - `cluster_drain_sched` (b_prefetch only) stage1 inner-loop - interleave: per-cluster `s_setprio` bracketing each `mfma_cluster` MFMAs - (not one coarse bracket) and a partial-`vmcnt` staircase that keeps the - prefetched B loads in flight per cluster instead of one full drain. - Default off — existing callers are bit-identical. + `cluster_drain_sched` (b_prefetch only) switches the 1-deep steady loop to + an interleaved B-issue schedule: the next tile's B fragments are issued + per-k *between* the current tile's MFMA phases (not front-loaded), each phase + pinned by `sched_barrier(0)` + bracketed by `s_setprio`, and the + end-of-tile sync is a bare `s_barrier` + `lgkmcnt`-only drain so in-flight + B DMAs cross it. (deep_prime / the epilogue still use the per-cluster + `vmcnt` staircase, `mma_chain_scheduled`.) Default off — callers + bit-identical unless opted in. `deep_prime` (b_prefetch only, num_tiles >= 2) deepens the A pipeline to 2-tiles-ahead: the prologue stages BOTH tile0 -> slot0 and tile1 -> slot1 @@ -481,6 +482,9 @@ struct MXFP4MatmulAMD_PreB[ `num_a_slots=2` LDS buffers — no extra LDS/VGPR. Composes with cluster_drain_sched/mfma_cluster (the MFMA chain is unchanged). Falls back to the 1-deep path when num_tiles < 2. Default off — existing callers are bit-identical. + + MFMA consumption order is B-major (n-outer / m-inner): the B fragment is + held resident across the m-loop for better MFMA ILP. See `mma`. """ # WM is locked to BM — single warp along M for the preb (no-LDS-B) path. @@ -733,6 +737,20 @@ struct MXFP4MatmulAMD_PreB[ # isn't preempted by memory-issuing waves; lower it for loads. llvm_intrinsic["llvm.amdgcn.s.setprio", NoneType](priority) + @always_inline + @parameter + def _sched_barrier_zero(): + # Hard reorder fence: pins surrounding instrs to source order so the + # scheduler can't hoist the interleaved B loads back into one block. + llvm_intrinsic["llvm.amdgcn.sched.barrier", NoneType](Int32(0)) + + @always_inline + @parameter + def _s_barrier_raw(): + # Bare s_barrier (no vmcnt/lgkmcnt release) so in-flight B DMAs + # cross it; stdlib barrier() forces vmcnt(0) and kills the prefetch. + llvm_intrinsic["llvm.amdgcn.s.barrier", NoneType]() + # Per-cluster setprio + partial-vmcnt staircase. # Splits the num_k_mmas MFMA chain into mfma_cluster-sized groups, # brackets each with s_setprio[1]/[0], and drains the prefetched @@ -892,12 +910,30 @@ struct MXFP4MatmulAMD_PreB[ comptime nxt_slot = (i + 1) % 2 var nxt_k_byte_base = (i + 1) * Self.BK_BYTES - comptime for k in range(Self.num_k_mmas): - mma_op.load_b_frag_preshuffled[k, slot=nxt_slot]( - b_loader, warp_n_off_global, nxt_k_byte_base - ) - - mma_chain[cur_slot]() + comptime if Self.cluster_drain_sched: + # issue next-tile B[k] spread + # between the current-tile MFMA phases, each group pinned by + # sched_barrier(0) so the scheduler can't re-block the loads + # into one burst (the front-load we want to break apart). + var a_warp = a_smem_slot(cur_slot).tile[ + Self.WM, Self.BK_BYTES + ](warp_m, 0) + comptime for k in range(Self.num_k_mmas): + mma_op.load_b_frag_preshuffled[k, slot=nxt_slot]( + b_loader, warp_n_off_global, nxt_k_byte_base + ) + _sched_barrier_zero() + s_setprio[1]() + mma_op.load_a_frag_from_smem[k](a_warp) + mma_op.mma[k, slot=cur_slot]() + s_setprio[0]() + _sched_barrier_zero() + else: + comptime for k in range(Self.num_k_mmas): + mma_op.load_b_frag_preshuffled[k, slot=nxt_slot]( + b_loader, warp_n_off_global, nxt_k_byte_base + ) + mma_chain[cur_slot]() # Double-buffered A: iter i reads `cur_slot` and writes the # next tile into `nxt_slot`, so the old WAR barrier here is @@ -907,7 +943,13 @@ struct MXFP4MatmulAMD_PreB[ load_a_tile_from_dram() copy_a_tile_to_smem(nxt_slot) load_scales_for_iter((i + 1) * mma_k_pair_per_tile) - barrier() + comptime if Self.cluster_drain_sched: + # Publish the A LDS tile cross-wave (lgkmcnt) but let the + # next-tile B DMAs keep streaming across the barrier. + s_waitcnt[lgkmcnt=0]() + _s_barrier_raw() + else: + barrier() # Epilogue: MFMA the last iter from its slot. comptime last_slot = (num_tiles - 1) % 2 diff --git a/max/kernels/test/gpu/linalg/test_mxfp4_grouped_matmul_amd_kernels.mojo b/max/kernels/test/gpu/linalg/test_mxfp4_grouped_matmul_amd_kernels.mojo index 91439c7fea5..aace6941b2d 100644 --- a/max/kernels/test/gpu/linalg/test_mxfp4_grouped_matmul_amd_kernels.mojo +++ b/max/kernels/test/gpu/linalg/test_mxfp4_grouped_matmul_amd_kernels.mojo @@ -161,6 +161,8 @@ def _run_preb[ BN: Int = 128, WN: Int = 64, b_cache_policy: CacheOperation = CacheOperation.ALWAYS, + cluster_drain_sched: Bool = False, + mfma_cluster: Int = 4, waves_per_eu: Int = 0, wg_per_cu: Int = 2, # struct param — sizes the persistent grid ]( @@ -363,6 +365,8 @@ def _run_preb[ WN=WN, persistent=persistent, b_cache_policy=b_cache_policy, + cluster_drain_sched=cluster_drain_sched, + mfma_cluster=mfma_cluster, waves_per_eu=waves_per_eu, ]( c_tt, @@ -419,6 +423,8 @@ def test_persistent[ BN: Int = 128, WN: Int = 64, b_cache_policy: CacheOperation = CacheOperation.ALWAYS, + cluster_drain_sched: Bool = False, + mfma_cluster: Int = 4, waves_per_eu: Int = 0, wg_per_cu: Int = 2, ]( @@ -447,6 +453,8 @@ def test_persistent[ BN=BN, WN=WN, b_cache_policy=b_cache_policy, + cluster_drain_sched=cluster_drain_sched, + mfma_cluster=mfma_cluster, waves_per_eu=waves_per_eu, wg_per_cu=wg_per_cu, ](name, num_tokens_by_expert, expert_ids_list, ctx) @@ -462,6 +470,8 @@ def test_direct[ BN: Int = 128, WN: Int = 64, b_cache_policy: CacheOperation = CacheOperation.ALWAYS, + cluster_drain_sched: Bool = False, + mfma_cluster: Int = 4, waves_per_eu: Int = 0, wg_per_cu: Int = 2, ]( @@ -484,6 +494,8 @@ def test_direct[ BN=BN, WN=WN, b_cache_policy=b_cache_policy, + cluster_drain_sched=cluster_drain_sched, + mfma_cluster=mfma_cluster, waves_per_eu=waves_per_eu, wg_per_cu=wg_per_cu, ](name, num_tokens_by_expert, expert_ids_list, ctx) @@ -518,22 +530,26 @@ def main() raises: print("---- preb persistent kernel ----") # Structural edge cases (L2 decode shape: N=512, K=2048). - test_persistent[1, 512, 2048]("single-tiny", [16], [0], ctx) - test_persistent[1, 512, 2048]("single-mid", [128], [0], ctx) - test_persistent[4, 512, 2048]( + test_persistent[1, 512, 2048, cluster_drain_sched=True]( + "single-tiny", [16], [0], ctx + ) + test_persistent[1, 512, 2048, cluster_drain_sched=True]( + "single-mid", [128], [0], ctx + ) + test_persistent[4, 512, 2048, cluster_drain_sched=True]( "multi-mixed", [32, 64, 128, 256], [0, 1, 2, 3], ctx ) - test_persistent[4, 512, 2048]( + test_persistent[4, 512, 2048, cluster_drain_sched=True]( "inactive-M0", [64, 0, 128, 32], [0, 1, 2, 3], ctx ) - test_persistent[4, 512, 2048]( + test_persistent[4, 512, 2048, cluster_drain_sched=True]( "inactive-eid-1", [64, 64, 128, 32], [0, -1, 2, 3], ctx ) # More tiles than total_wg (= 512 on MI355X) — exercise multi-wave per WG. # 9 experts × m_count=4 × gx_n(N=1024)=8 = 288 tiles? need >512. # 9 × m_count=8 × gx_n=8 = 576 → M=512 per expert. - test_persistent[9, 1024, 512]( + test_persistent[9, 1024, 512, cluster_drain_sched=True]( "multi-wave", [512, 512, 512, 512, 512, 512, 512, 512, 512], [0, 1, 2, 3, 4, 5, 6, 7, 8], @@ -543,7 +559,7 @@ def main() raises: # Kimi-decode-like: 49 active experts, very few tokens each, mixed # inactive slots (slot 40: M=0; slot 47: expert_id=-1) — matches the # L2.2 / L2.3 pattern from test_mxfp4_moe_matmul_amd_routed. - test_persistent[49, 512, 2048]( + test_persistent[49, 512, 2048, cluster_drain_sched=True]( "kimi-decode-49experts", [ 3, @@ -651,7 +667,7 @@ def main() raises: ) # Kimi-prefill scaled (L2.4): 49 active experts, ~40 tokens each. - test_persistent[49, 512, 2048]( + test_persistent[49, 512, 2048, cluster_drain_sched=True]( "kimi-prefill-49experts", [ 40, @@ -763,56 +779,62 @@ def main() raises: print("---- preb persistent kernel — tile-size variants ----") # BM=16 path: 1-row-per-sub-MMA M, shrui scale rotation on odd-parity CTAs. - test_persistent[4, 512, 2048, BM=16, BN=128, WN=64]( - "bm16-default-wn", [16, 32, 8, 48], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, 512, 2048, BM=16, BN=128, WN=64, cluster_drain_sched=True + ]("bm16-default-wn", [16, 32, 8, 48], [0, 1, 2, 3], ctx) # WN=16 path: N-side shrui rotation; BM unchanged. - test_persistent[4, 512, 2048, BM=64, BN=64, WN=16]( - "wn16-default-bm", [64, 32, 16, 48], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, 512, 2048, BM=64, BN=64, WN=16, cluster_drain_sched=True + ]("wn16-default-bm", [64, 32, 16, 48], [0, 1, 2, 3], ctx) # Both BM=16 and WN=16 — exercises both shrui paths simultaneously. - test_persistent[4, 256, 2048, BM=16, BN=64, WN=16]( - "bm16-wn16", [16, 32, 8, 24], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, 256, 2048, BM=16, BN=64, WN=16, cluster_drain_sched=True + ]("bm16-wn16", [16, 32, 8, 24], [0, 1, 2, 3], ctx) # Smaller BN=64 with default BM/WN — exercises the N-tile dispatcher # at a non-default BN. - test_persistent[4, 256, 2048, BM=64, BN=64, WN=64]( - "bn64", [64, 128, 32, 96], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, 256, 2048, BM=64, BN=64, WN=64, cluster_drain_sched=True + ]("bn64", [64, 128, 32, 96], [0, 1, 2, 3], ctx) # ----------------------------------------------------------------- # # Preb direct kernel — launch[persistent=False] # ----------------------------------------------------------------- # print("---- preb direct kernel ----") - test_direct[1, 512, 2048]("single-tiny", [16], [0], ctx) - test_direct[1, 512, 2048]("single-mid", [128], [0], ctx) - test_direct[4, 512, 2048]( + test_direct[1, 512, 2048, cluster_drain_sched=True]( + "single-tiny", [16], [0], ctx + ) + test_direct[1, 512, 2048, cluster_drain_sched=True]( + "single-mid", [128], [0], ctx + ) + test_direct[4, 512, 2048, cluster_drain_sched=True]( "multi-mixed", [32, 64, 128, 256], [0, 1, 2, 3], ctx ) - test_direct[4, 512, 2048]( + test_direct[4, 512, 2048, cluster_drain_sched=True]( "inactive-M0", [64, 0, 128, 32], [0, 1, 2, 3], ctx ) - test_direct[4, 512, 2048]( + test_direct[4, 512, 2048, cluster_drain_sched=True]( "inactive-eid-1", [64, 64, 128, 32], [0, -1, 2, 3], ctx ) # Large single-expert prefill (where direct typically wins over persistent). - test_direct[1, 1024, 512]("single-large", [8192], [0], ctx) + test_direct[1, 1024, 512, cluster_drain_sched=True]( + "single-large", [8192], [0], ctx + ) # Tile-size variants on the direct path. print("---- preb direct kernel — tile-size variants ----") - test_direct[4, 256, 2048, BM=16, BN=64, WN=16]( + test_direct[4, 256, 2048, BM=16, BN=64, WN=16, cluster_drain_sched=True]( "bm16-wn16", [3, 7, 1, 5], [0, 1, 2, 3], ctx ) - test_direct[4, 512, 2048, BM=64, BN=64, WN=16]( + test_direct[4, 512, 2048, BM=64, BN=64, WN=16, cluster_drain_sched=True]( "wn16-default-bm", [128, 64, 32, 48], [0, 1, 2, 3], ctx ) # Kimi-prefill scaled. - test_direct[49, 512, 2048]( + test_direct[49, 512, 2048, cluster_drain_sched=True]( "kimi-prefill-49experts", [ 40, @@ -931,36 +953,85 @@ def main() raises: # ----------------------------------------------------------------- # print("---- production band coverage: KIMI up-proj (N=4096, K=7168) ----") # band M==1 (decode) - test_persistent[4, 4096, 7168, BM=16, BN=64, BK_ELEMS=512, WN=16]( - "up M==1", [1, 1, 1, 1], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, + 4096, + 7168, + BM=16, + BN=64, + BK_ELEMS=512, + WN=16, + cluster_drain_sched=True, + ]("up M==1", [1, 1, 1, 1], [0, 1, 2, 3], ctx) # band 2<=M<=4 - test_persistent[4, 4096, 7168, BM=16, BN=128, BK_ELEMS=512, WN=32]( - "up 2..4", [4, 2, 3, 4], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, + 4096, + 7168, + BM=16, + BN=128, + BK_ELEMS=512, + WN=32, + cluster_drain_sched=True, + ]("up 2..4", [4, 2, 3, 4], [0, 1, 2, 3], ctx) # band 17<=M<=400 - test_persistent[4, 4096, 7168, BM=32, BN=128, BK_ELEMS=512, WN=32]( - "up 17..400", [200, 64, 128, 32], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, + 4096, + 7168, + BM=32, + BN=128, + BK_ELEMS=512, + WN=32, + cluster_drain_sched=True, + ]("up 17..400", [200, 64, 128, 32], [0, 1, 2, 3], ctx) # default persistent fallback (M in the 5..16 / 401..4095 gaps) - test_persistent[4, 4096, 7168, BM=64, BN=128, BK_ELEMS=512, WN=64]( - "up default-fallback", [512, 128, 256, 0], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, + 4096, + 7168, + BM=64, + BN=128, + BK_ELEMS=512, + WN=64, + cluster_drain_sched=True, + ]("up default-fallback", [512, 128, 256, 0], [0, 1, 2, 3], ctx) # use_direct path (persistent=False). Token count kept modest for memory; # the dispatcher is bypassed so M doesn't select the band — the config does. - test_direct[1, 4096, 7168, BM=64, BN=128, BK_ELEMS=512, WN=64]( - "up direct", [1024], [0], ctx - ) + test_direct[ + 1, + 4096, + 7168, + BM=64, + BN=128, + BK_ELEMS=512, + WN=64, + cluster_drain_sched=True, + ]("up direct", [1024], [0], ctx) print("---- production band coverage: KIMI down-proj (N=7168, K=2048) ----") # band M==1 (decode) - test_persistent[4, 7168, 2048, BM=16, BN=128, BK_ELEMS=512, WN=32]( - "down M==1", [1, 1, 1, 1], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, + 7168, + 2048, + BM=16, + BN=128, + BK_ELEMS=512, + WN=32, + cluster_drain_sched=True, + ]("down M==1", [1, 1, 1, 1], [0, 1, 2, 3], ctx) # band 2<=M<=7 (B cached) - test_persistent[4, 7168, 2048, BM=16, BN=256, BK_ELEMS=256, WN=64]( - "down 2..7 cached", [4, 2, 6, 3], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, + 7168, + 2048, + BM=16, + BN=256, + BK_ELEMS=256, + WN=64, + cluster_drain_sched=True, + ]("down 2..7 cached", [4, 2, 6, 3], [0, 1, 2, 3], ctx) # band 8<=M<=16 (B STREAMING) test_persistent[ 4, @@ -971,11 +1042,19 @@ def main() raises: BK_ELEMS=256, WN=64, b_cache_policy=CacheOperation.STREAMING, + cluster_drain_sched=True, ]("down 8..16 STREAMING", [12, 8, 16, 10], [0, 1, 2, 3], ctx) # band 17<=M<=37 / 385<=M<=400 (same config, B cached) - test_persistent[4, 7168, 2048, BM=32, BN=256, BK_ELEMS=512, WN=64]( - "down 17..37 / 385..400 cached", [32, 24, 37, 0], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, + 7168, + 2048, + BM=32, + BN=256, + BK_ELEMS=512, + WN=64, + cluster_drain_sched=True, + ]("down 17..37 / 385..400 cached", [32, 24, 37, 0], [0, 1, 2, 3], ctx) # band 38<=M<=384 (B STREAMING) test_persistent[ 4, @@ -986,98 +1065,249 @@ def main() raises: BK_ELEMS=512, WN=64, b_cache_policy=CacheOperation.STREAMING, + cluster_drain_sched=True, ]("down 38..384 STREAMING", [128, 96, 128, 64], [0, 1, 2, 3], ctx) # band 401<=M<=1200 (BK_ELEMS=256, B cached) - test_persistent[4, 7168, 2048, BM=64, BN=256, BK_ELEMS=256, WN=64]( - "down 401..1200 cached", [256, 256, 128, 64], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, + 7168, + 2048, + BM=64, + BN=256, + BK_ELEMS=256, + WN=64, + cluster_drain_sched=True, + ]("down 401..1200 cached", [256, 256, 128, 64], [0, 1, 2, 3], ctx) # default persistent fallback (M in the 1201..4095 gap) - test_persistent[4, 7168, 2048, BM=64, BN=128, BK_ELEMS=512, WN=64]( - "down default-fallback", [384, 128, 128, 0], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, + 7168, + 2048, + BM=64, + BN=128, + BK_ELEMS=512, + WN=64, + cluster_drain_sched=True, + ]("down default-fallback", [384, 128, 128, 0], [0, 1, 2, 3], ctx) # use_direct path (persistent=False); token count kept modest for memory. - test_direct[1, 7168, 2048, BM=64, BN=128, BK_ELEMS=512, WN=64]( - "down direct", [512], [0], ctx - ) + test_direct[ + 1, + 7168, + 2048, + BM=64, + BN=128, + BK_ELEMS=512, + WN=64, + cluster_drain_sched=True, + ]("down direct", [512], [0], ctx) - # waves_per_eu is a codegen hint; results must be unchanged. print("---- preb waves_per_eu EU-bounding cap ----") - test_persistent[4, 512, 2048, waves_per_eu=1]( + test_persistent[4, 512, 2048, waves_per_eu=1, cluster_drain_sched=True]( "wpe=1 persistent", [128, 96, 128, 64], [0, 1, 2, 3], ctx ) - test_persistent[4, 512, 2048, waves_per_eu=2]( + test_persistent[4, 512, 2048, waves_per_eu=2, cluster_drain_sched=True]( "wpe=2 persistent", [128, 96, 128, 64], [0, 1, 2, 3], ctx ) test_direct[ - 1, 7168, 2048, BM=64, BN=128, BK_ELEMS=512, WN=64, waves_per_eu=2 + 1, + 7168, + 2048, + BM=64, + BN=128, + BK_ELEMS=512, + WN=64, + waves_per_eu=2, + cluster_drain_sched=True, ]("wpe=2 direct", [512], [0], ctx) # Each band config the retuned dispatcher selects. print("---- retuned dispatcher band configs ----") comptime SX = CacheOperation.STREAMING test_persistent[ - 4, 4096, 7168, BM=16, BN=128, BK_ELEMS=512, WN=32, b_cache_policy=SX + 4, + 4096, + 7168, + BM=16, + BN=128, + BK_ELEMS=512, + WN=32, + b_cache_policy=SX, + cluster_drain_sched=True, ]("up BM16/BN128 STREAM", [128, 96, 128, 64], [0, 1, 2, 3], ctx) test_persistent[ - 4, 4096, 7168, BM=32, BN=128, BK_ELEMS=512, WN=32, b_cache_policy=SX + 4, + 4096, + 7168, + BM=32, + BN=128, + BK_ELEMS=512, + WN=32, + b_cache_policy=SX, + cluster_drain_sched=True, ]("up BM32/BN128 STREAM", [256, 256, 256, 256], [0, 1, 2, 3], ctx) - test_persistent[4, 7168, 2048, BM=16, BN=64, BK_ELEMS=512, WN=16]( - "down BN64 tiny", [2, 1, 0, 1], [0, 1, 2, 3], ctx - ) test_persistent[ - 4, 7168, 2048, BM=16, BN=128, BK_ELEMS=512, WN=32, b_cache_policy=SX + 4, + 7168, + 2048, + BM=16, + BN=64, + BK_ELEMS=512, + WN=16, + cluster_drain_sched=True, + ]("down BN64 tiny", [2, 1, 0, 1], [0, 1, 2, 3], ctx) + test_persistent[ + 4, + 7168, + 2048, + BM=16, + BN=128, + BK_ELEMS=512, + WN=32, + b_cache_policy=SX, + cluster_drain_sched=True, ]("down BM16/BN128 STREAM", [128, 96, 128, 64], [0, 1, 2, 3], ctx) test_persistent[ - 4, 7168, 2048, BM=32, BN=128, BK_ELEMS=512, WN=32, b_cache_policy=SX + 4, + 7168, + 2048, + BM=32, + BN=128, + BK_ELEMS=512, + WN=32, + b_cache_policy=SX, + cluster_drain_sched=True, ]("down BM32/BN128 STREAM", [256, 256, 256, 256], [0, 1, 2, 3], ctx) test_persistent[ - 4, 7168, 2048, BM=64, BN=128, BK_ELEMS=512, WN=64, b_cache_policy=SX + 4, + 7168, + 2048, + BM=64, + BN=128, + BK_ELEMS=512, + WN=64, + b_cache_policy=SX, + cluster_drain_sched=True, ]("down BM64/BN128 STREAM", [512, 512, 256, 256], [0, 1, 2, 3], ctx) - test_direct[1, 7168, 2048, BM=64, BN=128, BK_ELEMS=256, WN=64]( - "down direct BK256", [512], [0], ctx - ) + test_direct[ + 1, + 7168, + 2048, + BM=64, + BN=128, + BK_ELEMS=256, + WN=64, + cluster_drain_sched=True, + ]("down direct BK256", [512], [0], ctx) # Remaining bands the retuned dispatcher can select, plus the real # EP=4 batch-1 decode point and a skewed-routing stress case. # up etm<=20 ALWAYS band (16,64,512,16). - test_persistent[4, 4096, 7168, BM=16, BN=64, BK_ELEMS=512, WN=16]( - "up BM16/BN64 tiny ALWAYS", [8, 4, 0, 4], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, + 4096, + 7168, + BM=16, + BN=64, + BK_ELEMS=512, + WN=16, + cluster_drain_sched=True, + ]("up BM16/BN64 tiny ALWAYS", [8, 4, 0, 4], [0, 1, 2, 3], ctx) # up etm<=4095 STREAM band (64,128,512,64). Token count kept modest to # stay under the harness HBM ceiling; config is what's under test. test_persistent[ - 4, 4096, 7168, BM=64, BN=128, BK_ELEMS=512, WN=64, b_cache_policy=SX + 4, + 4096, + 7168, + BM=64, + BN=128, + BK_ELEMS=512, + WN=64, + b_cache_policy=SX, + cluster_drain_sched=True, ]("up BM64/BN128 STREAM", [192, 192, 128, 128], [0, 1, 2, 3], ctx) # up else direct band (64,128,512,64). - test_direct[1, 4096, 7168, BM=64, BN=128, BK_ELEMS=512, WN=64]( - "up direct", [512], [0], ctx - ) + test_direct[ + 1, + 4096, + 7168, + BM=64, + BN=128, + BK_ELEMS=512, + WN=64, + cluster_drain_sched=True, + ]("up direct", [512], [0], ctx) # etm==1 wg_per_cu=1 variant for both shapes (16,64,512,16). wg_per_cu is # a grid-sizing comptime; results must match the wg_per_cu=2 default. test_persistent[ - 4, 4096, 7168, BM=16, BN=64, BK_ELEMS=512, WN=16, wg_per_cu=1 + 4, + 4096, + 7168, + BM=16, + BN=64, + BK_ELEMS=512, + WN=16, + wg_per_cu=1, + cluster_drain_sched=True, ]("up etm1 wg_per_cu=1", [1, 0, 0, 0], [0, 1, 2, 3], ctx) test_persistent[ - 4, 7168, 2048, BM=16, BN=64, BK_ELEMS=512, WN=16, wg_per_cu=1 + 4, + 7168, + 2048, + BM=16, + BN=64, + BK_ELEMS=512, + WN=16, + wg_per_cu=1, + cluster_drain_sched=True, ]("down etm1 wg_per_cu=1", [1, 0, 0, 0], [0, 1, 2, 3], ctx) # True EP=4 batch-1 decode point: 2 experts, 1 row each (M=2), tile # (16,64,512,16) for both up and down. - test_persistent[4, 4096, 7168, BM=16, BN=64, BK_ELEMS=512, WN=16]( - "up EP4 decode M=2", [1, 1, 0, 0], [0, 1, 2, 3], ctx - ) - test_persistent[4, 7168, 2048, BM=16, BN=64, BK_ELEMS=512, WN=16]( - "down EP4 decode M=2", [1, 1, 0, 0], [0, 1, 2, 3], ctx - ) + test_persistent[ + 4, + 4096, + 7168, + BM=16, + BN=64, + BK_ELEMS=512, + WN=16, + cluster_drain_sched=True, + ]("up EP4 decode M=2", [1, 1, 0, 0], [0, 1, 2, 3], ctx) + test_persistent[ + 4, + 7168, + 2048, + BM=16, + BN=64, + BK_ELEMS=512, + WN=16, + cluster_drain_sched=True, + ]("down EP4 decode M=2", [1, 1, 0, 0], [0, 1, 2, 3], ctx) # Skewed routing (one hot expert, etm~203 -> (16,128,512,32) STREAM band). # Stresses persistent work-stealing under imbalance. test_persistent[ - 4, 4096, 7168, BM=16, BN=128, BK_ELEMS=512, WN=32, b_cache_policy=SX + 4, + 4096, + 7168, + BM=16, + BN=128, + BK_ELEMS=512, + WN=32, + b_cache_policy=SX, + cluster_drain_sched=True, ]("up skewed hot expert", [200, 1, 1, 1], [0, 1, 2, 3], ctx) test_persistent[ - 4, 7168, 2048, BM=16, BN=128, BK_ELEMS=512, WN=32, b_cache_policy=SX + 4, + 7168, + 2048, + BM=16, + BN=128, + BK_ELEMS=512, + WN=32, + b_cache_policy=SX, + cluster_drain_sched=True, ]("down skewed hot expert", [200, 1, 1, 1], [0, 1, 2, 3], ctx) print("==== all preb grouped MXFP4 kernel tests passed ====") From 0916f13e0e61d751a128c21214261b83fb9590d5 Mon Sep 17 00:00:00 2001 From: modularbot Date: Mon, 22 Jun 2026 08:00:11 +0000 Subject: [PATCH 4/4] [Release] Pin lockfiles to Mojo 1.0.0b3.dev2026062206, MAX 26.5.0.dev2026062206 --- bazel/mojo.MODULE.bazel | 4 +- max/examples/capi/pixi.lock | 142 +++++----- max/examples/custom-models/pixi.lock | 244 +++++++++--------- max/examples/custom_ops/pixi.lock | 142 +++++----- max/examples/modules/pixi.lock | 244 +++++++++--------- max/examples/offline-inference/pixi.lock | 244 +++++++++--------- max/examples/pytorch_custom_ops/pixi.lock | 244 +++++++++--------- .../code/manual/tile-tensor/layouts/pixi.lock | 122 ++++----- .../code/manual/tile-tensor/tensors/pixi.lock | 122 ++++----- mojo/examples/gpu-block-and-warp/pixi.lock | 122 ++++----- mojo/examples/gpu-functions/pixi.lock | 122 ++++----- mojo/examples/gpu-intro/pixi.lock | 122 ++++----- mojo/examples/layout_tensor/pixi.lock | 122 ++++----- mojo/examples/layouts/pixi.lock | 122 ++++----- mojo/examples/life/pixi.lock | 126 ++++----- mojo/examples/operators/pixi.lock | 122 ++++----- mojo/examples/python-interop/pixi.lock | 122 ++++----- mojo/examples/testing/pixi.lock | 122 ++++----- mojo/pixi.lock | 122 ++++----- 19 files changed, 1366 insertions(+), 1366 deletions(-) diff --git a/bazel/mojo.MODULE.bazel b/bazel/mojo.MODULE.bazel index 1dae3a4552b..dca5f5f5f84 100644 --- a/bazel/mojo.MODULE.bazel +++ b/bazel/mojo.MODULE.bazel @@ -1,8 +1,8 @@ """Define the Mojo toolchain""" -MAX_PACKAGE_VERSION = "26.5.0.dev2026062114" +MAX_PACKAGE_VERSION = "26.5.0.dev2026062206" -MOJO_PACKAGE_VERSION = "1.0.0b3.dev2026062114" +MOJO_PACKAGE_VERSION = "1.0.0b3.dev2026062206" BASE_URL = "https://whl.modular.com/nightly" diff --git a/max/examples/capi/pixi.lock b/max/examples/capi/pixi.lock index ff0a09c291c..346ec46ab97 100644 --- a/max/examples/capi/pixi.lock +++ b/max/examples/capi/pixi.lock @@ -31,11 +31,11 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - - conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062114-3.14release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062206-3.14release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/msgspec-0.21.1-py314h5bd0f2a_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.4.6-py314h2b28147_0.conda @@ -80,11 +80,11 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcrypt-4.4.36-h31becfc_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062114-3.12release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062206-3.12release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/msgspec-0.21.1-py312hcd1a082_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-2.4.6-py312hce9e0af_0.conda @@ -125,11 +125,11 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062114-3.14release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062206-3.14release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/msgspec-0.21.1-py314h6c2aa35_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.4.6-py314hb79c6fa_0.conda @@ -858,9 +858,9 @@ packages: license_family: MIT size: 69017 timestamp: 1778169663339 -- conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062114-3.14release.conda - sha256: bd1c00215645e7be17b7200551b94520ab65271252c210018b28caada9e021be - md5: 4936bea23fa926d66922505d30541976 +- conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062206-3.14release.conda + sha256: e36ee5fdffeb1681eca1c1f03a0a7d91ecff31ac593596e81b7bdbad42dc2b9e + md5: c0f5cce2703034764d4febc8a25cb209 depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -870,13 +870,13 @@ packages: - typing-extensions >=4.12.2 - python 3.14.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 7776114 - timestamp: 1782051792785 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062114-3.12release.conda - sha256: d5e50ec1a13a085f92de609d49f9d96ee4d3779edab6b19ba47175afaf6b8014 - md5: 16dbe0e0e2db9a9ef4700013d4a45186 + size: 7775773 + timestamp: 1782111871344 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062206-3.12release.conda + sha256: 73a03dd22437ca130eb03e182d14f15185e63dee372c18bf96a1879bbc8e9fc8 + md5: c725c425cfc755595dae2a595b0ee512 depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -886,13 +886,13 @@ packages: - typing-extensions >=4.12.2 - python 3.12.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 7688151 - timestamp: 1782051795143 -- conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062114-3.14release.conda - sha256: fe87ff56bf2e8613f20dce37d2b9f2bf228d4bb51a34138da91fa74ae491eff2 - md5: 368cc518b510bbb9d68ce25599634e13 + size: 7688468 + timestamp: 1782111939810 +- conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062206-3.14release.conda + sha256: 9c72a4d9543fbeaa61b50d71974564592c5b0f4ae1072f8a8a051fcfb21a273f + md5: 4d98d31252ad0aeb17b6bf3f8a7c94e7 depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -902,34 +902,34 @@ packages: - typing-extensions >=4.12.2 - python 3.14.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 6976341 - timestamp: 1782051953389 -- conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062114-release.conda - sha256: dd10f192e002f1f7d9e7f0fa32f1ebbba0cb35e2bc64b1c3637d1579fb85d957 - md5: 31453d813459ce057aa6be0a3f6bae88 + size: 6976077 + timestamp: 1782112070968 +- conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062206-release.conda + sha256: 7a88ae9ee754f60b6f5d36bbc448408c4bbe9e1cac91b7a81dfb266777365a11 + md5: 8cccb09cf50e868709fa3895ca8bd775 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 87255869 - timestamp: 1782051826832 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062114-release.conda - sha256: 37d91235df7699c30af1be8fc2ddd99df3ab368007f229ee0d7b073d1c8df94b - md5: 02882fc4415ee58b78b3c0da80ef8f66 + size: 87283648 + timestamp: 1782111899826 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062206-release.conda + sha256: 633e9bfc8c4d8df06745fdc1dd9be554e46a7bc569c9e0a5d8f35770fa1fbae2 + md5: 77d3912b0a301d8bb1ffaa6db43ede33 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 55187977 - timestamp: 1782051816599 -- conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062114-release.conda - sha256: d00b2faf96c52e5f4756b40e8b2cad0a0e75a4f9f0be1ba7b015a802fecacafa - md5: ad46c42a0f5d558f8e1b529393c20826 + size: 55211968 + timestamp: 1782111927310 +- conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062206-release.conda + sha256: e90dc28b48a30201b6f2032bd1b525038f2559569d47bc91776bcd24efeb780e + md5: 8f8a2d16176269441ec7b21746649ba2 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 51435367 - timestamp: 1782051923513 + size: 51458396 + timestamp: 1782112039401 - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 md5: 592132998493b3ff25fd7479396e8351 @@ -939,39 +939,39 @@ packages: license_family: MIT size: 14465 timestamp: 1733255681319 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/linux-64/msgspec-0.21.1-py314h5bd0f2a_0.conda sha256: 52565ceea81e801c59dcaeaf5a9c77fba2fade445e67e0864fda50d4b944e15b md5: 4a8ea416a56e58f012e445f7af2bbcc8 diff --git a/max/examples/custom-models/pixi.lock b/max/examples/custom-models/pixi.lock index 9f0dc38dad3..c6e99498e9f 100644 --- a/max/examples/custom-models/pixi.lock +++ b/max/examples/custom-models/pixi.lock @@ -171,15 +171,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/llguidance-1.7.6-py310hc9716df_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.3-py313h3dea7bd_1.conda - - conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062114-3.13release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062206-3.13release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mpg123-1.32.9-hc50e24c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/msgspec-0.21.1-py313h07c4f96_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda @@ -452,15 +452,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/llguidance-1.7.6-py310he4c756e_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/markupsafe-3.0.3-py313hfa222a2_1.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062114-3.13release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062206-3.13release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpg123-1.32.9-h65af167_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/msgspec-0.21.1-py313h6194ac5_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda @@ -711,15 +711,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.3-py313h65a2061_1.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062114-3.13release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062206-3.13release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/msgspec-0.21.1-py313h0997733_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda @@ -5263,9 +5263,9 @@ packages: license_family: BSD size: 26009 timestamp: 1772445537524 -- conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062114-3.13release.conda - sha256: b8766682d58b025d5569d15c44df745490b700be2bf0fafb02972bb157d98e16 - md5: 452999e4d79d29f4d04c10166d144cd0 +- conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062206-3.13release.conda + sha256: 6a703cb60b656fac25403e19987eb492db07200897ee78f462961258444f379a + md5: ed5bee3d90e70fffeee635b3e7cb8add depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -5275,13 +5275,13 @@ packages: - typing-extensions >=4.12.2 - python 3.13.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 7775121 - timestamp: 1782051792785 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062114-3.13release.conda - sha256: df90d8e0f78f871e7cd9fe1476d5f82eef0794200a9758918eb2344ba6a9f9fb - md5: dfee68eb53cc2213580917867661d916 + size: 7774821 + timestamp: 1782111871344 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062206-3.13release.conda + sha256: b6784b46346e7f95d2455327793698674b18ba86a169372708ed42c56cda780f + md5: ca9b9b14c8661d0ebd51a15cf8080f54 depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -5291,13 +5291,13 @@ packages: - typing-extensions >=4.12.2 - python 3.13.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 7688996 - timestamp: 1782051795144 -- conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062114-3.13release.conda - sha256: e4ba80c7d4d4e3ca659a2ed9688aa4bd4c545d534570d9f316cd5bde43cc154b - md5: 59bd8fd4f8fc87046f9e1eff4098624b + size: 7688595 + timestamp: 1782111939811 +- conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062206-3.13release.conda + sha256: 53b134465ae48d174a9ce0d27bc3081e455e76fb83329060ac307998897a9380 + md5: 4df3ed323ce04562edcb4b52ec2229a3 depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -5307,38 +5307,38 @@ packages: - typing-extensions >=4.12.2 - python 3.13.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 6974111 - timestamp: 1782051953388 -- conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062114-release.conda - sha256: dd10f192e002f1f7d9e7f0fa32f1ebbba0cb35e2bc64b1c3637d1579fb85d957 - md5: 31453d813459ce057aa6be0a3f6bae88 + size: 6973686 + timestamp: 1782112070967 +- conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062206-release.conda + sha256: 7a88ae9ee754f60b6f5d36bbc448408c4bbe9e1cac91b7a81dfb266777365a11 + md5: 8cccb09cf50e868709fa3895ca8bd775 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 87255869 - timestamp: 1782051826832 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062114-release.conda - sha256: 37d91235df7699c30af1be8fc2ddd99df3ab368007f229ee0d7b073d1c8df94b - md5: 02882fc4415ee58b78b3c0da80ef8f66 + size: 87283648 + timestamp: 1782111899826 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062206-release.conda + sha256: 633e9bfc8c4d8df06745fdc1dd9be554e46a7bc569c9e0a5d8f35770fa1fbae2 + md5: 77d3912b0a301d8bb1ffaa6db43ede33 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 55187977 - timestamp: 1782051816599 -- conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062114-release.conda - sha256: d00b2faf96c52e5f4756b40e8b2cad0a0e75a4f9f0be1ba7b015a802fecacafa - md5: ad46c42a0f5d558f8e1b529393c20826 + size: 55211968 + timestamp: 1782111927310 +- conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062206-release.conda + sha256: e90dc28b48a30201b6f2032bd1b525038f2559569d47bc91776bcd24efeb780e + md5: 8f8a2d16176269441ec7b21746649ba2 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 51435367 - timestamp: 1782051923513 -- conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda + size: 51458396 + timestamp: 1782112039401 +- conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda noarch: python - sha256: 1656800ccde9a1e5bba17d9a5f59e921ae9944ab8439e9c6946ebffcf8772d56 - md5: 49f69ee8bac93685f8844abd88adda28 + sha256: da79e904f9a6ab61d43e5b668d2df8791aaeed1c7725fafb122e359c7cc9566a + md5: 4dcf42e3e8ca75033816034d5dd8ec5f depends: - huggingface_hub >=0.28.0 - jinja2 >=3.1.0 @@ -5381,14 +5381,14 @@ packages: - scipy >=1.13.0 - sse-starlette >=2.1.2 - starlette >=0.47.2 - - max ==26.5.0.dev2026062114 + - max ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 16289 - timestamp: 1782051511079 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + size: 16287 + timestamp: 1782111584696 +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -5398,8 +5398,8 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 + size: 134714 + timestamp: 1782111584721 - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 md5: 592132998493b3ff25fd7479396e8351 @@ -5409,82 +5409,82 @@ packages: license_family: MIT size: 14465 timestamp: 1733255681319 -- conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda noarch: python - sha256: 67add1278de6a8a07ec291ef712707953d45a4b6cfb75cbcda05165392405a7b - md5: 8a8d6c016aaf9562ca489898f9db3bda + sha256: ba1e0d8b9b0aa57dbef068fd1b85a33fb24f1b41a42757161ab84dfb324f3ad6 + md5: f9d72000150b48d09fdf4e9344a7fb17 depends: - - max-pipelines ==26.5.0.dev2026062114 - - mojo ==1.0.0b3.dev2026062114 + - max-pipelines ==26.5.0.dev2026062206 + - mojo ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 15811 - timestamp: 1782051510906 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 15809 + timestamp: 1782111584772 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/linux-64/mpg123-1.32.9-hc50e24c_0.conda sha256: 39c4700fb3fbe403a77d8cc27352fa72ba744db487559d5d44bf8411bb4ea200 md5: c7f302fd11eeb0987a6a5e1f3aed6a21 diff --git a/max/examples/custom_ops/pixi.lock b/max/examples/custom_ops/pixi.lock index a8efb21c22e..0e24a29d814 100644 --- a/max/examples/custom_ops/pixi.lock +++ b/max/examples/custom_ops/pixi.lock @@ -42,11 +42,11 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - - conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062114-3.13release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062206-3.13release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/msgspec-0.21.1-py313h07c4f96_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.4.6-py313hf6604e3_0.conda @@ -106,11 +106,11 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcb-1.17.0-h262b8f6_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062114-3.13release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062206-3.13release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/msgspec-0.21.1-py313h6194ac5_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-2.4.6-py313h839dfd1_0.conda @@ -168,11 +168,11 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062114-3.13release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062206-3.13release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/msgspec-0.21.1-py313h0997733_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.4.6-py313hce9b930_0.conda @@ -1224,9 +1224,9 @@ packages: license_family: MIT size: 69017 timestamp: 1778169663339 -- conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062114-3.13release.conda - sha256: b8766682d58b025d5569d15c44df745490b700be2bf0fafb02972bb157d98e16 - md5: 452999e4d79d29f4d04c10166d144cd0 +- conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062206-3.13release.conda + sha256: 6a703cb60b656fac25403e19987eb492db07200897ee78f462961258444f379a + md5: ed5bee3d90e70fffeee635b3e7cb8add depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -1236,13 +1236,13 @@ packages: - typing-extensions >=4.12.2 - python 3.13.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 7775121 - timestamp: 1782051792785 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062114-3.13release.conda - sha256: df90d8e0f78f871e7cd9fe1476d5f82eef0794200a9758918eb2344ba6a9f9fb - md5: dfee68eb53cc2213580917867661d916 + size: 7774821 + timestamp: 1782111871344 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062206-3.13release.conda + sha256: b6784b46346e7f95d2455327793698674b18ba86a169372708ed42c56cda780f + md5: ca9b9b14c8661d0ebd51a15cf8080f54 depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -1252,13 +1252,13 @@ packages: - typing-extensions >=4.12.2 - python 3.13.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 7688996 - timestamp: 1782051795144 -- conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062114-3.13release.conda - sha256: e4ba80c7d4d4e3ca659a2ed9688aa4bd4c545d534570d9f316cd5bde43cc154b - md5: 59bd8fd4f8fc87046f9e1eff4098624b + size: 7688595 + timestamp: 1782111939811 +- conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062206-3.13release.conda + sha256: 53b134465ae48d174a9ce0d27bc3081e455e76fb83329060ac307998897a9380 + md5: 4df3ed323ce04562edcb4b52ec2229a3 depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -1268,34 +1268,34 @@ packages: - typing-extensions >=4.12.2 - python 3.13.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 6974111 - timestamp: 1782051953388 -- conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062114-release.conda - sha256: dd10f192e002f1f7d9e7f0fa32f1ebbba0cb35e2bc64b1c3637d1579fb85d957 - md5: 31453d813459ce057aa6be0a3f6bae88 + size: 6973686 + timestamp: 1782112070967 +- conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062206-release.conda + sha256: 7a88ae9ee754f60b6f5d36bbc448408c4bbe9e1cac91b7a81dfb266777365a11 + md5: 8cccb09cf50e868709fa3895ca8bd775 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 87255869 - timestamp: 1782051826832 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062114-release.conda - sha256: 37d91235df7699c30af1be8fc2ddd99df3ab368007f229ee0d7b073d1c8df94b - md5: 02882fc4415ee58b78b3c0da80ef8f66 + size: 87283648 + timestamp: 1782111899826 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062206-release.conda + sha256: 633e9bfc8c4d8df06745fdc1dd9be554e46a7bc569c9e0a5d8f35770fa1fbae2 + md5: 77d3912b0a301d8bb1ffaa6db43ede33 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 55187977 - timestamp: 1782051816599 -- conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062114-release.conda - sha256: d00b2faf96c52e5f4756b40e8b2cad0a0e75a4f9f0be1ba7b015a802fecacafa - md5: ad46c42a0f5d558f8e1b529393c20826 + size: 55211968 + timestamp: 1782111927310 +- conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062206-release.conda + sha256: e90dc28b48a30201b6f2032bd1b525038f2559569d47bc91776bcd24efeb780e + md5: 8f8a2d16176269441ec7b21746649ba2 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 51435367 - timestamp: 1782051923513 + size: 51458396 + timestamp: 1782112039401 - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 md5: 592132998493b3ff25fd7479396e8351 @@ -1305,39 +1305,39 @@ packages: license_family: MIT size: 14465 timestamp: 1733255681319 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/linux-64/msgspec-0.21.1-py313h07c4f96_0.conda sha256: a44d23085117672e4e19629ea3e6c53f516984322513c4bfdd052b1c7c6fc8ad md5: 15c679f7133347d68058b688f3519cea diff --git a/max/examples/modules/pixi.lock b/max/examples/modules/pixi.lock index d2501904316..2c7f6007721 100644 --- a/max/examples/modules/pixi.lock +++ b/max/examples/modules/pixi.lock @@ -171,15 +171,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/llguidance-1.7.6-py310hc9716df_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.3-py313h3dea7bd_1.conda - - conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062114-3.13release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062206-3.13release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mpg123-1.32.9-hc50e24c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/msgspec-0.21.1-py313h07c4f96_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda @@ -452,15 +452,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/llguidance-1.7.6-py310he4c756e_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/markupsafe-3.0.3-py313hfa222a2_1.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062114-3.13release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062206-3.13release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpg123-1.32.9-h65af167_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/msgspec-0.21.1-py313h6194ac5_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda @@ -711,15 +711,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.3-py313h65a2061_1.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062114-3.13release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062206-3.13release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/msgspec-0.21.1-py313h0997733_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda @@ -5263,9 +5263,9 @@ packages: license_family: BSD size: 26009 timestamp: 1772445537524 -- conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062114-3.13release.conda - sha256: b8766682d58b025d5569d15c44df745490b700be2bf0fafb02972bb157d98e16 - md5: 452999e4d79d29f4d04c10166d144cd0 +- conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062206-3.13release.conda + sha256: 6a703cb60b656fac25403e19987eb492db07200897ee78f462961258444f379a + md5: ed5bee3d90e70fffeee635b3e7cb8add depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -5275,13 +5275,13 @@ packages: - typing-extensions >=4.12.2 - python 3.13.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 7775121 - timestamp: 1782051792785 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062114-3.13release.conda - sha256: df90d8e0f78f871e7cd9fe1476d5f82eef0794200a9758918eb2344ba6a9f9fb - md5: dfee68eb53cc2213580917867661d916 + size: 7774821 + timestamp: 1782111871344 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062206-3.13release.conda + sha256: b6784b46346e7f95d2455327793698674b18ba86a169372708ed42c56cda780f + md5: ca9b9b14c8661d0ebd51a15cf8080f54 depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -5291,13 +5291,13 @@ packages: - typing-extensions >=4.12.2 - python 3.13.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 7688996 - timestamp: 1782051795144 -- conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062114-3.13release.conda - sha256: e4ba80c7d4d4e3ca659a2ed9688aa4bd4c545d534570d9f316cd5bde43cc154b - md5: 59bd8fd4f8fc87046f9e1eff4098624b + size: 7688595 + timestamp: 1782111939811 +- conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062206-3.13release.conda + sha256: 53b134465ae48d174a9ce0d27bc3081e455e76fb83329060ac307998897a9380 + md5: 4df3ed323ce04562edcb4b52ec2229a3 depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -5307,38 +5307,38 @@ packages: - typing-extensions >=4.12.2 - python 3.13.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 6974111 - timestamp: 1782051953388 -- conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062114-release.conda - sha256: dd10f192e002f1f7d9e7f0fa32f1ebbba0cb35e2bc64b1c3637d1579fb85d957 - md5: 31453d813459ce057aa6be0a3f6bae88 + size: 6973686 + timestamp: 1782112070967 +- conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062206-release.conda + sha256: 7a88ae9ee754f60b6f5d36bbc448408c4bbe9e1cac91b7a81dfb266777365a11 + md5: 8cccb09cf50e868709fa3895ca8bd775 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 87255869 - timestamp: 1782051826832 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062114-release.conda - sha256: 37d91235df7699c30af1be8fc2ddd99df3ab368007f229ee0d7b073d1c8df94b - md5: 02882fc4415ee58b78b3c0da80ef8f66 + size: 87283648 + timestamp: 1782111899826 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062206-release.conda + sha256: 633e9bfc8c4d8df06745fdc1dd9be554e46a7bc569c9e0a5d8f35770fa1fbae2 + md5: 77d3912b0a301d8bb1ffaa6db43ede33 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 55187977 - timestamp: 1782051816599 -- conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062114-release.conda - sha256: d00b2faf96c52e5f4756b40e8b2cad0a0e75a4f9f0be1ba7b015a802fecacafa - md5: ad46c42a0f5d558f8e1b529393c20826 + size: 55211968 + timestamp: 1782111927310 +- conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062206-release.conda + sha256: e90dc28b48a30201b6f2032bd1b525038f2559569d47bc91776bcd24efeb780e + md5: 8f8a2d16176269441ec7b21746649ba2 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 51435367 - timestamp: 1782051923513 -- conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda + size: 51458396 + timestamp: 1782112039401 +- conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda noarch: python - sha256: 1656800ccde9a1e5bba17d9a5f59e921ae9944ab8439e9c6946ebffcf8772d56 - md5: 49f69ee8bac93685f8844abd88adda28 + sha256: da79e904f9a6ab61d43e5b668d2df8791aaeed1c7725fafb122e359c7cc9566a + md5: 4dcf42e3e8ca75033816034d5dd8ec5f depends: - huggingface_hub >=0.28.0 - jinja2 >=3.1.0 @@ -5381,14 +5381,14 @@ packages: - scipy >=1.13.0 - sse-starlette >=2.1.2 - starlette >=0.47.2 - - max ==26.5.0.dev2026062114 + - max ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 16289 - timestamp: 1782051511079 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + size: 16287 + timestamp: 1782111584696 +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -5398,8 +5398,8 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 + size: 134714 + timestamp: 1782111584721 - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 md5: 592132998493b3ff25fd7479396e8351 @@ -5409,82 +5409,82 @@ packages: license_family: MIT size: 14465 timestamp: 1733255681319 -- conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda noarch: python - sha256: 67add1278de6a8a07ec291ef712707953d45a4b6cfb75cbcda05165392405a7b - md5: 8a8d6c016aaf9562ca489898f9db3bda + sha256: ba1e0d8b9b0aa57dbef068fd1b85a33fb24f1b41a42757161ab84dfb324f3ad6 + md5: f9d72000150b48d09fdf4e9344a7fb17 depends: - - max-pipelines ==26.5.0.dev2026062114 - - mojo ==1.0.0b3.dev2026062114 + - max-pipelines ==26.5.0.dev2026062206 + - mojo ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 15811 - timestamp: 1782051510906 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 15809 + timestamp: 1782111584772 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/linux-64/mpg123-1.32.9-hc50e24c_0.conda sha256: 39c4700fb3fbe403a77d8cc27352fa72ba744db487559d5d44bf8411bb4ea200 md5: c7f302fd11eeb0987a6a5e1f3aed6a21 diff --git a/max/examples/offline-inference/pixi.lock b/max/examples/offline-inference/pixi.lock index 9f0dc38dad3..c6e99498e9f 100644 --- a/max/examples/offline-inference/pixi.lock +++ b/max/examples/offline-inference/pixi.lock @@ -171,15 +171,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/llguidance-1.7.6-py310hc9716df_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.3-py313h3dea7bd_1.conda - - conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062114-3.13release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062206-3.13release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mpg123-1.32.9-hc50e24c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/msgspec-0.21.1-py313h07c4f96_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda @@ -452,15 +452,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/llguidance-1.7.6-py310he4c756e_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/markupsafe-3.0.3-py313hfa222a2_1.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062114-3.13release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062206-3.13release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpg123-1.32.9-h65af167_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/msgspec-0.21.1-py313h6194ac5_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda @@ -711,15 +711,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.3-py313h65a2061_1.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062114-3.13release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062206-3.13release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/msgspec-0.21.1-py313h0997733_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda @@ -5263,9 +5263,9 @@ packages: license_family: BSD size: 26009 timestamp: 1772445537524 -- conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062114-3.13release.conda - sha256: b8766682d58b025d5569d15c44df745490b700be2bf0fafb02972bb157d98e16 - md5: 452999e4d79d29f4d04c10166d144cd0 +- conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062206-3.13release.conda + sha256: 6a703cb60b656fac25403e19987eb492db07200897ee78f462961258444f379a + md5: ed5bee3d90e70fffeee635b3e7cb8add depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -5275,13 +5275,13 @@ packages: - typing-extensions >=4.12.2 - python 3.13.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 7775121 - timestamp: 1782051792785 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062114-3.13release.conda - sha256: df90d8e0f78f871e7cd9fe1476d5f82eef0794200a9758918eb2344ba6a9f9fb - md5: dfee68eb53cc2213580917867661d916 + size: 7774821 + timestamp: 1782111871344 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062206-3.13release.conda + sha256: b6784b46346e7f95d2455327793698674b18ba86a169372708ed42c56cda780f + md5: ca9b9b14c8661d0ebd51a15cf8080f54 depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -5291,13 +5291,13 @@ packages: - typing-extensions >=4.12.2 - python 3.13.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 7688996 - timestamp: 1782051795144 -- conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062114-3.13release.conda - sha256: e4ba80c7d4d4e3ca659a2ed9688aa4bd4c545d534570d9f316cd5bde43cc154b - md5: 59bd8fd4f8fc87046f9e1eff4098624b + size: 7688595 + timestamp: 1782111939811 +- conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062206-3.13release.conda + sha256: 53b134465ae48d174a9ce0d27bc3081e455e76fb83329060ac307998897a9380 + md5: 4df3ed323ce04562edcb4b52ec2229a3 depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -5307,38 +5307,38 @@ packages: - typing-extensions >=4.12.2 - python 3.13.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 6974111 - timestamp: 1782051953388 -- conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062114-release.conda - sha256: dd10f192e002f1f7d9e7f0fa32f1ebbba0cb35e2bc64b1c3637d1579fb85d957 - md5: 31453d813459ce057aa6be0a3f6bae88 + size: 6973686 + timestamp: 1782112070967 +- conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062206-release.conda + sha256: 7a88ae9ee754f60b6f5d36bbc448408c4bbe9e1cac91b7a81dfb266777365a11 + md5: 8cccb09cf50e868709fa3895ca8bd775 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 87255869 - timestamp: 1782051826832 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062114-release.conda - sha256: 37d91235df7699c30af1be8fc2ddd99df3ab368007f229ee0d7b073d1c8df94b - md5: 02882fc4415ee58b78b3c0da80ef8f66 + size: 87283648 + timestamp: 1782111899826 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062206-release.conda + sha256: 633e9bfc8c4d8df06745fdc1dd9be554e46a7bc569c9e0a5d8f35770fa1fbae2 + md5: 77d3912b0a301d8bb1ffaa6db43ede33 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 55187977 - timestamp: 1782051816599 -- conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062114-release.conda - sha256: d00b2faf96c52e5f4756b40e8b2cad0a0e75a4f9f0be1ba7b015a802fecacafa - md5: ad46c42a0f5d558f8e1b529393c20826 + size: 55211968 + timestamp: 1782111927310 +- conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062206-release.conda + sha256: e90dc28b48a30201b6f2032bd1b525038f2559569d47bc91776bcd24efeb780e + md5: 8f8a2d16176269441ec7b21746649ba2 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 51435367 - timestamp: 1782051923513 -- conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda + size: 51458396 + timestamp: 1782112039401 +- conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda noarch: python - sha256: 1656800ccde9a1e5bba17d9a5f59e921ae9944ab8439e9c6946ebffcf8772d56 - md5: 49f69ee8bac93685f8844abd88adda28 + sha256: da79e904f9a6ab61d43e5b668d2df8791aaeed1c7725fafb122e359c7cc9566a + md5: 4dcf42e3e8ca75033816034d5dd8ec5f depends: - huggingface_hub >=0.28.0 - jinja2 >=3.1.0 @@ -5381,14 +5381,14 @@ packages: - scipy >=1.13.0 - sse-starlette >=2.1.2 - starlette >=0.47.2 - - max ==26.5.0.dev2026062114 + - max ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 16289 - timestamp: 1782051511079 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + size: 16287 + timestamp: 1782111584696 +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -5398,8 +5398,8 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 + size: 134714 + timestamp: 1782111584721 - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 md5: 592132998493b3ff25fd7479396e8351 @@ -5409,82 +5409,82 @@ packages: license_family: MIT size: 14465 timestamp: 1733255681319 -- conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda noarch: python - sha256: 67add1278de6a8a07ec291ef712707953d45a4b6cfb75cbcda05165392405a7b - md5: 8a8d6c016aaf9562ca489898f9db3bda + sha256: ba1e0d8b9b0aa57dbef068fd1b85a33fb24f1b41a42757161ab84dfb324f3ad6 + md5: f9d72000150b48d09fdf4e9344a7fb17 depends: - - max-pipelines ==26.5.0.dev2026062114 - - mojo ==1.0.0b3.dev2026062114 + - max-pipelines ==26.5.0.dev2026062206 + - mojo ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 15811 - timestamp: 1782051510906 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 15809 + timestamp: 1782111584772 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/linux-64/mpg123-1.32.9-hc50e24c_0.conda sha256: 39c4700fb3fbe403a77d8cc27352fa72ba744db487559d5d44bf8411bb4ea200 md5: c7f302fd11eeb0987a6a5e1f3aed6a21 diff --git a/max/examples/pytorch_custom_ops/pixi.lock b/max/examples/pytorch_custom_ops/pixi.lock index 27d86849cbe..662786b033d 100644 --- a/max/examples/pytorch_custom_ops/pixi.lock +++ b/max/examples/pytorch_custom_ops/pixi.lock @@ -223,16 +223,16 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/lz4-c-1.10.0-h5888daf_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.3-py314h67df5f8_1.conda - - conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062114-3.14release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062206-3.14release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mkl-2026.0.0-hecca717_915.conda - - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.4.0-he0a73b1_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.2-he0a73b1_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mpg123-1.32.9-hc50e24c_0.conda @@ -585,15 +585,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lz4-c-1.10.0-h5ad3122_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/markupsafe-3.0.3-py314hb76de3f_1.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062114-3.14release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062206-3.14release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpc-1.4.0-he6dc3fb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpfr-4.2.2-h3faef18_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpg123-1.32.9-h65af167_0.conda @@ -924,15 +924,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lz4-c-1.10.0-h286801f_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.3-py314h6e9b3f0_1.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062114-3.14release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062206-3.14release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpc-1.4.0-h169892a_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.2-h6bc93b0_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mpmath-1.4.1-pyhd8ed1ab_0.conda @@ -7452,9 +7452,9 @@ packages: license_family: BSD size: 27256 timestamp: 1772445397216 -- conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062114-3.14release.conda - sha256: bd1c00215645e7be17b7200551b94520ab65271252c210018b28caada9e021be - md5: 4936bea23fa926d66922505d30541976 +- conda: https://conda.modular.com/max-nightly/linux-64/max-26.5.0.dev2026062206-3.14release.conda + sha256: e36ee5fdffeb1681eca1c1f03a0a7d91ecff31ac593596e81b7bdbad42dc2b9e + md5: c0f5cce2703034764d4febc8a25cb209 depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -7464,13 +7464,13 @@ packages: - typing-extensions >=4.12.2 - python 3.14.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 7776114 - timestamp: 1782051792785 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062114-3.14release.conda - sha256: 95ecbe0366c4915f06c2cb309649284b5c1291662a3179bb5252965d35536659 - md5: ce5e73b790f44c871339b4a6a4ee3a0c + size: 7775773 + timestamp: 1782111871344 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-26.5.0.dev2026062206-3.14release.conda + sha256: 1c84cbbd29571292e1a2871ae6150a77e333ef1026d1877e33f0e7a377163b07 + md5: dc7e49f476f5443b6108dbcd1483bf8d depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -7480,13 +7480,13 @@ packages: - typing-extensions >=4.12.2 - python 3.14.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 7691167 - timestamp: 1782051795144 -- conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062114-3.14release.conda - sha256: fe87ff56bf2e8613f20dce37d2b9f2bf228d4bb51a34138da91fa74ae491eff2 - md5: 368cc518b510bbb9d68ce25599634e13 + size: 7690527 + timestamp: 1782111939811 +- conda: https://conda.modular.com/max-nightly/osx-arm64/max-26.5.0.dev2026062206-3.14release.conda + sha256: 9c72a4d9543fbeaa61b50d71974564592c5b0f4ae1072f8a8a051fcfb21a273f + md5: 4d98d31252ad0aeb17b6bf3f8a7c94e7 depends: - msgspec >=0.19.0 - numpy >=1.18 @@ -7496,38 +7496,38 @@ packages: - typing-extensions >=4.12.2 - python 3.14.* - python-gil - - max-core ==26.5.0.dev2026062114 + - max-core ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 6976341 - timestamp: 1782051953389 -- conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062114-release.conda - sha256: dd10f192e002f1f7d9e7f0fa32f1ebbba0cb35e2bc64b1c3637d1579fb85d957 - md5: 31453d813459ce057aa6be0a3f6bae88 + size: 6976077 + timestamp: 1782112070968 +- conda: https://conda.modular.com/max-nightly/linux-64/max-core-26.5.0.dev2026062206-release.conda + sha256: 7a88ae9ee754f60b6f5d36bbc448408c4bbe9e1cac91b7a81dfb266777365a11 + md5: 8cccb09cf50e868709fa3895ca8bd775 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 87255869 - timestamp: 1782051826832 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062114-release.conda - sha256: 37d91235df7699c30af1be8fc2ddd99df3ab368007f229ee0d7b073d1c8df94b - md5: 02882fc4415ee58b78b3c0da80ef8f66 + size: 87283648 + timestamp: 1782111899826 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/max-core-26.5.0.dev2026062206-release.conda + sha256: 633e9bfc8c4d8df06745fdc1dd9be554e46a7bc569c9e0a5d8f35770fa1fbae2 + md5: 77d3912b0a301d8bb1ffaa6db43ede33 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 55187977 - timestamp: 1782051816599 -- conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062114-release.conda - sha256: d00b2faf96c52e5f4756b40e8b2cad0a0e75a4f9f0be1ba7b015a802fecacafa - md5: ad46c42a0f5d558f8e1b529393c20826 + size: 55211968 + timestamp: 1782111927310 +- conda: https://conda.modular.com/max-nightly/osx-arm64/max-core-26.5.0.dev2026062206-release.conda + sha256: e90dc28b48a30201b6f2032bd1b525038f2559569d47bc91776bcd24efeb780e + md5: 8f8a2d16176269441ec7b21746649ba2 depends: - - mojo-compiler ==1.0.0b3.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 51435367 - timestamp: 1782051923513 -- conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062114-release.conda + size: 51458396 + timestamp: 1782112039401 +- conda: https://conda.modular.com/max-nightly/noarch/max-pipelines-26.5.0.dev2026062206-release.conda noarch: python - sha256: 1656800ccde9a1e5bba17d9a5f59e921ae9944ab8439e9c6946ebffcf8772d56 - md5: 49f69ee8bac93685f8844abd88adda28 + sha256: da79e904f9a6ab61d43e5b668d2df8791aaeed1c7725fafb122e359c7cc9566a + md5: 4dcf42e3e8ca75033816034d5dd8ec5f depends: - huggingface_hub >=0.28.0 - jinja2 >=3.1.0 @@ -7570,14 +7570,14 @@ packages: - scipy >=1.13.0 - sse-starlette >=2.1.2 - starlette >=0.47.2 - - max ==26.5.0.dev2026062114 + - max ==26.5.0.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 16289 - timestamp: 1782051511079 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda + size: 16287 + timestamp: 1782111584696 +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -7587,8 +7587,8 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 + size: 134714 + timestamp: 1782111584721 - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 md5: 592132998493b3ff25fd7479396e8351 @@ -7614,82 +7614,82 @@ packages: license_family: Proprietary size: 143201396 timestamp: 1781016571972 -- conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/modular-26.5.0.dev2026062206-release.conda noarch: python - sha256: 67add1278de6a8a07ec291ef712707953d45a4b6cfb75cbcda05165392405a7b - md5: 8a8d6c016aaf9562ca489898f9db3bda + sha256: ba1e0d8b9b0aa57dbef068fd1b85a33fb24f1b41a42757161ab84dfb324f3ad6 + md5: f9d72000150b48d09fdf4e9344a7fb17 depends: - - max-pipelines ==26.5.0.dev2026062114 - - mojo ==1.0.0b3.dev2026062114 + - max-pipelines ==26.5.0.dev2026062206 + - mojo ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 15811 - timestamp: 1782051510906 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 15809 + timestamp: 1782111584772 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.4.0-he0a73b1_0.conda sha256: c1fdeebc9f8e4f51df265efca4ea20c7a13911193cc255db73cccb6e422ae486 md5: 770d00bf57b5599c4544d61b61d8c6c6 diff --git a/mojo/docs/code/manual/tile-tensor/layouts/pixi.lock b/mojo/docs/code/manual/tile-tensor/layouts/pixi.lock index c39349fd7e9..1354328ff85 100644 --- a/mojo/docs/code/manual/tile-tensor/layouts/pixi.lock +++ b/mojo/docs/code/manual/tile-tensor/layouts/pixi.lock @@ -32,10 +32,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda @@ -83,10 +83,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda @@ -128,10 +128,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.2-h1ae2325_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda @@ -722,10 +722,10 @@ packages: license_family: Other size: 47759 timestamp: 1774072956767 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -735,74 +735,74 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 134714 + timestamp: 1782111584721 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1 md5: e9c622e0d00fa24a6292279af3ab6d06 diff --git a/mojo/docs/code/manual/tile-tensor/tensors/pixi.lock b/mojo/docs/code/manual/tile-tensor/tensors/pixi.lock index c39349fd7e9..1354328ff85 100644 --- a/mojo/docs/code/manual/tile-tensor/tensors/pixi.lock +++ b/mojo/docs/code/manual/tile-tensor/tensors/pixi.lock @@ -32,10 +32,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda @@ -83,10 +83,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda @@ -128,10 +128,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.2-h1ae2325_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda @@ -722,10 +722,10 @@ packages: license_family: Other size: 47759 timestamp: 1774072956767 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -735,74 +735,74 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 134714 + timestamp: 1782111584721 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1 md5: e9c622e0d00fa24a6292279af3ab6d06 diff --git a/mojo/examples/gpu-block-and-warp/pixi.lock b/mojo/examples/gpu-block-and-warp/pixi.lock index c39349fd7e9..1354328ff85 100644 --- a/mojo/examples/gpu-block-and-warp/pixi.lock +++ b/mojo/examples/gpu-block-and-warp/pixi.lock @@ -32,10 +32,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda @@ -83,10 +83,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda @@ -128,10 +128,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.2-h1ae2325_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda @@ -722,10 +722,10 @@ packages: license_family: Other size: 47759 timestamp: 1774072956767 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -735,74 +735,74 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 134714 + timestamp: 1782111584721 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1 md5: e9c622e0d00fa24a6292279af3ab6d06 diff --git a/mojo/examples/gpu-functions/pixi.lock b/mojo/examples/gpu-functions/pixi.lock index c39349fd7e9..1354328ff85 100644 --- a/mojo/examples/gpu-functions/pixi.lock +++ b/mojo/examples/gpu-functions/pixi.lock @@ -32,10 +32,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda @@ -83,10 +83,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda @@ -128,10 +128,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.2-h1ae2325_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda @@ -722,10 +722,10 @@ packages: license_family: Other size: 47759 timestamp: 1774072956767 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -735,74 +735,74 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 134714 + timestamp: 1782111584721 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1 md5: e9c622e0d00fa24a6292279af3ab6d06 diff --git a/mojo/examples/gpu-intro/pixi.lock b/mojo/examples/gpu-intro/pixi.lock index c39349fd7e9..1354328ff85 100644 --- a/mojo/examples/gpu-intro/pixi.lock +++ b/mojo/examples/gpu-intro/pixi.lock @@ -32,10 +32,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda @@ -83,10 +83,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda @@ -128,10 +128,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.2-h1ae2325_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda @@ -722,10 +722,10 @@ packages: license_family: Other size: 47759 timestamp: 1774072956767 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -735,74 +735,74 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 134714 + timestamp: 1782111584721 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1 md5: e9c622e0d00fa24a6292279af3ab6d06 diff --git a/mojo/examples/layout_tensor/pixi.lock b/mojo/examples/layout_tensor/pixi.lock index c39349fd7e9..1354328ff85 100644 --- a/mojo/examples/layout_tensor/pixi.lock +++ b/mojo/examples/layout_tensor/pixi.lock @@ -32,10 +32,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda @@ -83,10 +83,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda @@ -128,10 +128,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.2-h1ae2325_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda @@ -722,10 +722,10 @@ packages: license_family: Other size: 47759 timestamp: 1774072956767 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -735,74 +735,74 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 134714 + timestamp: 1782111584721 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1 md5: e9c622e0d00fa24a6292279af3ab6d06 diff --git a/mojo/examples/layouts/pixi.lock b/mojo/examples/layouts/pixi.lock index c39349fd7e9..1354328ff85 100644 --- a/mojo/examples/layouts/pixi.lock +++ b/mojo/examples/layouts/pixi.lock @@ -32,10 +32,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda @@ -83,10 +83,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda @@ -128,10 +128,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.2-h1ae2325_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda @@ -722,10 +722,10 @@ packages: license_family: Other size: 47759 timestamp: 1774072956767 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -735,74 +735,74 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 134714 + timestamp: 1782111584721 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1 md5: e9c622e0d00fa24a6292279af3ab6d06 diff --git a/mojo/examples/life/pixi.lock b/mojo/examples/life/pixi.lock index 2ea20c31373..047cbaff540 100644 --- a/mojo/examples/life/pixi.lock +++ b/mojo/examples/life/pixi.lock @@ -34,10 +34,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda @@ -86,10 +86,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda @@ -132,10 +132,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.2-h1ae2325_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda @@ -784,10 +784,10 @@ packages: purls: [] size: 47759 timestamp: 1774072956767 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -797,74 +797,74 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 134714 + timestamp: 1782111584721 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1 md5: e9c622e0d00fa24a6292279af3ab6d06 @@ -1148,7 +1148,7 @@ packages: license: BSD-3-Clause license_family: BSD purls: - - pkg:pypi/pyzmq?source=hash-mapping + - pkg:pypi/pyzmq?source=compressed-mapping size: 191432 timestamp: 1779484184540 - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda @@ -1285,7 +1285,7 @@ packages: license: Apache-2.0 license_family: Apache purls: - - pkg:pypi/tornado?source=hash-mapping + - pkg:pypi/tornado?source=compressed-mapping size: 889689 timestamp: 1781007967544 - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.15.1-pyhcf101f3_0.conda diff --git a/mojo/examples/operators/pixi.lock b/mojo/examples/operators/pixi.lock index c39349fd7e9..1354328ff85 100644 --- a/mojo/examples/operators/pixi.lock +++ b/mojo/examples/operators/pixi.lock @@ -32,10 +32,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda @@ -83,10 +83,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda @@ -128,10 +128,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.2-h1ae2325_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda @@ -722,10 +722,10 @@ packages: license_family: Other size: 47759 timestamp: 1774072956767 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -735,74 +735,74 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 134714 + timestamp: 1782111584721 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1 md5: e9c622e0d00fa24a6292279af3ab6d06 diff --git a/mojo/examples/python-interop/pixi.lock b/mojo/examples/python-interop/pixi.lock index c39349fd7e9..1354328ff85 100644 --- a/mojo/examples/python-interop/pixi.lock +++ b/mojo/examples/python-interop/pixi.lock @@ -32,10 +32,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda @@ -83,10 +83,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda @@ -128,10 +128,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.2-h1ae2325_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda @@ -722,10 +722,10 @@ packages: license_family: Other size: 47759 timestamp: 1774072956767 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -735,74 +735,74 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 134714 + timestamp: 1782111584721 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1 md5: e9c622e0d00fa24a6292279af3ab6d06 diff --git a/mojo/examples/testing/pixi.lock b/mojo/examples/testing/pixi.lock index c39349fd7e9..1354328ff85 100644 --- a/mojo/examples/testing/pixi.lock +++ b/mojo/examples/testing/pixi.lock @@ -32,10 +32,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda @@ -83,10 +83,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda @@ -128,10 +128,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.2-h1ae2325_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda @@ -722,10 +722,10 @@ packages: license_family: Other size: 47759 timestamp: 1774072956767 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -735,74 +735,74 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 134714 + timestamp: 1782111584721 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1 md5: e9c622e0d00fa24a6292279af3ab6d06 diff --git a/mojo/pixi.lock b/mojo/pixi.lock index c39349fd7e9..1354328ff85 100644 --- a/mojo/pixi.lock +++ b/mojo/pixi.lock @@ -32,10 +32,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda @@ -83,10 +83,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda @@ -128,10 +128,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.2-h1ae2325_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + - conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda @@ -722,10 +722,10 @@ packages: license_family: Other size: 47759 timestamp: 1774072956767 -- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062114-release.conda +- conda: https://conda.modular.com/max-nightly/noarch/mblack-26.5.0.dev2026062206-release.conda noarch: python - sha256: a522ecc25909e674adc9e39ac661d9805b3bd4df6a607312286237d21491649e - md5: bb970e01ce0e2f38d39505e7c94f23c8 + sha256: 4d976d7ac710fad4d9f2d85f52be037ff1dc65490c7a9d3951e38fd14829ce5f + md5: a8582212d25d17eff924068144c36057 depends: - python >=3.10 - click >=8.0.0 @@ -735,74 +735,74 @@ packages: - platformdirs >=2 - tomli >=1.1.0 license: LicenseRef-Modular-Proprietary - size: 134702 - timestamp: 1782051510213 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: c90142f31a8d9104fc05c2c617e54c0845b7b3ca2429432c8c4f142f9d35733c - md5: e8717f354be20bd45147160481224680 + size: 134714 + timestamp: 1782111584721 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 17baa5dd8fa3f75680236547126ba85a90fa4d24ea682951106e260cc2b23d28 + md5: 9d8de35f2c5a4ff73045a9d5bb796972 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 97010406 - timestamp: 1782051655659 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: ea37144be9d695997108b561fdfe39a60cfb7a4768608d0cc2ce90a5484d3c86 - md5: a9254fea0529e0bf2f08c08f239a259b + size: 97010386 + timestamp: 1782111727526 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: 741163d69d0b778edf3f8dda7940d4005edf83bd3dbf1d53fe44bb2dc1bd6705 + md5: 6bbcce09da9c68e5960d84c83465df0a depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 94878649 - timestamp: 1782051648383 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062114-release.conda - sha256: 1719537a845460c2739f2fb2689ac338949623632d97e67bc584969078fe1f07 - md5: a407e5130217ec02edcdfcba65c539ac + size: 94878868 + timestamp: 1782111740945 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-1.0.0b3.dev2026062206-release.conda + sha256: fe57b18d66c0bbe5f6d4674f03c1ce10b110f4ffb806647a6a17bca62fc638a7 + md5: 38dafaac68365b327443132afad6b326 depends: - python >=3.10 - - mojo-compiler ==1.0.0b3.dev2026062114 - - mblack ==26.5.0.dev2026062114 + - mojo-compiler ==1.0.0b3.dev2026062206 + - mblack ==26.5.0.dev2026062206 - jupyter_client >=8.6.2,<8.7 license: LicenseRef-Modular-Proprietary - size: 84950928 - timestamp: 1782051837994 -- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d4163ca6ee06967096b38160a3dd8b7fc956af42d1b7467c76d184eaba9b6a6a - md5: 74420b590ad2d0e01a9a2b29baee9ed4 + size: 84950922 + timestamp: 1782111947157 +- conda: https://conda.modular.com/max-nightly/linux-64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 9131156661b91cac2dda46ef81ffd0ff9e75b32fae476692a9a0fa53ae4e1dab + md5: d105935570d6ba1b90248d647e3e3766 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 81501296 - timestamp: 1782051683405 -- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: d1003c2e778a02109dede545c9f39ad5bf58168a412a481aafa154dd3fcb6ea3 - md5: a7a1862b31cacd22a0a95427fd5b51c9 + size: 81503901 + timestamp: 1782111755931 +- conda: https://conda.modular.com/max-nightly/linux-aarch64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 6226015d2b677af17ee8cb9d9b952c2079aaca55269120eef1bfc749e61b6e41 + md5: 35e5893bfeb62835e1c343be5eb5d925 depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 79213276 - timestamp: 1782051673345 -- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062114-release.conda - sha256: 7bf481e344565c48f7c8be1a5fea4211230c407d40966983fc124852131df2ea - md5: 2e7af2f0d28ab78ffb776f5c735eb290 + size: 79212310 + timestamp: 1782111774709 +- conda: https://conda.modular.com/max-nightly/osx-arm64/mojo-compiler-1.0.0b3.dev2026062206-release.conda + sha256: 683bc9f6e80263ab6a7ace188078d17495385c71db3e0454a5536bf8bf8abc09 + md5: 753d34586d6fba29c91b36ef76e1ef2a depends: - - mojo-python ==1.0.0b3.dev2026062114 + - mojo-python ==1.0.0b3.dev2026062206 license: LicenseRef-Modular-Proprietary - size: 63017843 - timestamp: 1782051836492 -- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062114-release.conda + size: 63016162 + timestamp: 1782111925765 +- conda: https://conda.modular.com/max-nightly/noarch/mojo-python-1.0.0b3.dev2026062206-release.conda noarch: python - sha256: e447ffc3619c362c18d5e4993cc3fd821b4adc99740c45a7cf50724f15f1577e - md5: f398fcb66970cb6167d437c61079ccd4 + sha256: 099d4d3e2184dad9fd6380d9a9382ee24752205a336dc5be431c4e8c63d86ef5 + md5: 0fbe948b4bf1c154077f9fa9372d4f28 depends: - python >=3.10 license: LicenseRef-Modular-Proprietary - size: 24113 - timestamp: 1782051510541 + size: 24091 + timestamp: 1782111584675 - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1 md5: e9c622e0d00fa24a6292279af3ab6d06