chore: update for mojo 25.4

Signed-off-by: Seth Stadick <sstadick@gmail.com>

Author: sstadick

.circleci/config.yml

@@ -31,6 +31,7 @@ jobs:
           name: Install Mojo and deps
           command: |
             export PATH="$PATH:/home/circleci/.pixi/bin"
+            pixi global install rattler-build
             pixi install --locked
       - run:
           name: Run tests

CHANGELOG.md

@@ -1,6 +1,10 @@
 
 # Next
 
+# v1.2.0 (06-19-2025)
+
+- Upgrade to Mojo 25.4
+
 # v1.1.1 (06-07-2025)
 
 - Added a compile time `ISH_SIMD_TARGET` flag that can be set to `baseline` to

ishlib/do_search.mojo

@@ -1,6 +1,5 @@
 from time.time import perf_counter
 
-from ExtraMojo.io import MovableWriter
 from ExtraMojo.io.buffered import BufferedWriter
 
 from ishlib.gpu import has_gpu
@@ -23,7 +22,7 @@ from ishlib.vendor.log import Logger
 
 
 fn do_search[
-    W: MovableWriter
+    W: Movable & Writer
 ](settings: SearcherSettings, owned writer: BufferedWriter[W]) raises:
     Logger.info(
         # fmt: off

ishlib/fastx_search_runner.mojo

@@ -1,4 +1,3 @@
-from ExtraMojo.io import MovableWriter
 from ExtraMojo.io.buffered import BufferedWriter
 
 from ishlib import RED, PURPLE, GREEN, ByteSpanWriter, RecordType
@@ -19,22 +18,22 @@ struct FastxSearchRunner[M: Matcher]:
     var matcher: M
 
     fn run_search[
-        W: MovableWriter
+        W: Movable & Writer
     ](mut self, mut writer: BufferedWriter[W]) raises:
         # Peek only the first file to determine fastq or not, assume not-binary
         var peek = peek_file[record_type = RecordType.FASTX](
             self.settings.files[0]
         )
         for file in self.settings.files:
-            var f = file[]  # force copy
+            var f = file  # force copy
             Logger.debug("Processing", f)
             if peek.is_fastq:
                 self.run_search_on_file[is_fastq=True](f, writer)
             else:
                 self.run_search_on_file[is_fastq=False](f, writer)
 
     fn run_search_on_file[
-        W: MovableWriter, *, is_fastq: Bool = False
+        W: Movable & Writer, *, is_fastq: Bool = False
     ](mut self, file: Path, mut writer: BufferedWriter[W]) raises:
         var reader = FastxReader[read_comment=False](
             BufferedReader(GZFile(String(file), "r"))

ishlib/gpu/process_batch.mojo

@@ -63,8 +63,8 @@ fn parallel_starts_ends[
 
     # Create the buffers
     var host_buffer_create_start = perf_counter()
-    for ctx in ctxs:
-        ctx[].set_block_info(
+    for ref ctx in ctxs:
+        ctx.set_block_info(
             targets_per_device,
             len(matcher.encoded_pattern()),
             matcher.matrix_len(),
@@ -74,10 +74,10 @@ fn parallel_starts_ends[
             settings.sg_ends_free,
             max_target_length=max_target_length,
         )
-        ctx[].host_create_input_buffers()
+        ctx.host_create_input_buffers()
 
     for ctx in ctxs:
-        ctx[].synchronize()
+        ctx.synchronize()
     var host_buffers_created = perf_counter()
     Logger.timing(
         "Host buffer creation time:",
@@ -108,16 +108,16 @@ fn parallel_starts_ends[
     Logger.timing("Buffer fill time:", buffers_filled - buffer_fill_start)
 
     # Launch Kernel
-    for ctx in ctxs:
-        ctx[].device_create_input_buffers()
-        ctx[].copy_inputs_to_device()
-        ctx[].device_create_output_buffers()
+    for ref ctx in ctxs:
+        ctx.device_create_input_buffers()
+        ctx.copy_inputs_to_device()
+        ctx.device_create_output_buffers()
         Logger.debug("Created device output buffers")
-        ctx[].launch_kernel()
+        ctx.launch_kernel()
         Logger.debug("Launched kernel")
-        ctx[].host_create_output_buffers()
+        ctx.host_create_output_buffers()
         Logger.debug("Created host output buffers")
-        ctx[].copy_outputs_to_host()
+        ctx.copy_outputs_to_host()
 
     # Process the long seqs
     var cpu_start = perf_counter()
@@ -127,7 +127,7 @@ fn parallel_starts_ends[
 
     # Get outputs
     for ctx in ctxs:
-        ctx[].synchronize()
+        ctx.synchronize()
         # ctx[].copy_outputs_to_host()
     var gpu_done = perf_counter()
     Logger.timing("GPU processing time (with cpu):", gpu_done - buffers_filled)
@@ -141,14 +141,14 @@ fn parallel_starts_ends[
     total_items = 0
     for ctx in ctxs:
         var end = min(
-            total_items + ctx[].block_info.value().num_targets, len(seqs)
+            total_items + ctx.block_info.value().num_targets, len(seqs)
         )
         var starts_start = perf_counter()
         cpu_parallel_starts[where_computed = WhereComputed.Gpu](
             matcher,
             settings,
-            ctx[].host_scores.value().as_span().get_immutable(),
-            ctx[].host_target_ends.value().as_span().get_immutable(),
+            ctx.host_scores.value().as_span().get_immutable(),
+            ctx.host_target_ends.value().as_span().get_immutable(),
             seqs[total_items:end],
             outputs,
             total_items,

ishlib/line_search_runner.mojo

@@ -1,4 +1,3 @@
-from ExtraMojo.io import MovableWriter
 from ExtraMojo.io.buffered import BufferedWriter
 
 from ishlib import RED, PURPLE, GREEN, ByteSpanWriter, RecordType
@@ -19,21 +18,21 @@ struct LineSearchRunner[M: Matcher]:
     var matcher: M
 
     fn run_search[
-        W: MovableWriter
+        W: Movable & Writer
     ](mut self, mut writer: BufferedWriter[W]) raises:
         # Simple thing first?
         for file in self.settings.files:
-            var f = file[]  # force copy
+            var f = file  # force copy
             var peek = peek_file[record_type = RecordType.LINE](f)
             if peek.is_binary:
                 if self.settings.verbose:
-                    Logger.warn("Skipping binary file:", file[])
+                    Logger.warn("Skipping binary file:", file)
                 continue
             Logger.debug("Processing", f)
             self.run_search_on_file(f, writer)
 
     fn run_search_on_file[
-        W: MovableWriter
+        W: Movable & Writer
     ](mut self, path: Path, mut writer: BufferedWriter[W]) raises:
         var file = String(path)
         var reader = BufferedReader(GZFile(file, "r"))

ishlib/matcher/__init__.mojo

@@ -115,7 +115,7 @@ trait GpuMatcher(Matcher):
         ...
 
 
-trait Searchable(Copyable, Movable, CollectionElement):
+trait Searchable(Copyable, Copyable, Movable, Movable):
     fn buffer_to_search(ref self) -> Span[UInt8, __origin_of(self)]:
         ...
 

ishlib/matcher/alignment/__init__.mojo

@@ -43,7 +43,9 @@ fn create_reversed(input: Span[UInt8]) -> List[UInt8]:
     return ret
 
 
-struct AlignedMemory[dtype: DType, width: Int, alignment: Int]:
+struct AlignedMemory[dtype: DType, width: Int, alignment: Int](
+    Copyable, Movable, Sized
+):
     var ptr: UnsafePointer[SIMD[dtype, width], alignment=alignment]
     var length: Int
 

ishlib/matcher/alignment/scoring_matrix.mojo

@@ -175,11 +175,11 @@ alias ACTGN0 = InlineArray[Int8, 25](
 
 @value
 @register_passable
-struct MatrixKind:
+struct MatrixKind(Sized, Stringable, Writable):
     var value: UInt8
     alias ASCII = Self(0)
     alias ACTGN = Self(1)
-    alias ACTGN0= Self(2)
+    alias ACTGN0 = Self(2)
     alias BLOSUM62 = Self(3)
 
     @staticmethod
@@ -411,7 +411,7 @@ struct ScoringMatrix:
         var score = 0
         var out = List[UInt8](capacity=len(seq))
         for value in seq:
-            var encoded = self.ascii_to_encoding[Int(value[])]
+            var encoded = self.ascii_to_encoding[Int(value)]
             score += Int(self.get(encoded, encoded))
             out.append(encoded)
         return (out, score)
@@ -427,7 +427,7 @@ struct ScoringMatrix:
     fn convert_ascii_to_encoding(read self, seq: Span[UInt8]) -> List[UInt8]:
         var out = List[UInt8](capacity=len(seq))
         for value in seq:
-            out.append(self.ascii_to_encoding[Int(value[])])
+            out.append(self.ascii_to_encoding[Int(value)])
         return out
 
     @always_inline
@@ -436,7 +436,7 @@ struct ScoringMatrix:
     ) -> List[UInt8]:
         var out = List[UInt8](capacity=len(seq))
         for value in seq:
-            out.append(self.ascii_to_encoding[Int(value[])])
+            out.append(self.ascii_to_encoding[Int(value)])
         return out
 
     @always_inline
@@ -447,22 +447,22 @@ struct ScoringMatrix:
     fn convert_ascii_to_encoding(
         read self, owned seq: List[UInt8]
     ) -> List[UInt8]:
-        for value in seq:
-            value[] = self.ascii_to_encoding[Int(value[])]
+        for ref value in seq:
+            value = self.ascii_to_encoding[Int(value)]
         return seq
 
     @always_inline
     fn convert_encoding_to_ascii(read self, mut seq: List[UInt8]):
-        for value in seq:
-            value[] = self.encoding_to_ascii[Int(value[])]
+        for ref value in seq:
+            value = self.encoding_to_ascii[Int(value)]
 
     @always_inline
     fn convert_encoding_to_ascii(
         read self, read seq: Span[UInt8]
     ) -> List[UInt8]:
         var out = List[UInt8](capacity=len(seq))
-        for value in seq:
-            out.append(self.encoding_to_ascii[Int(value[])])
+        for ref value in seq:
+            out.append(self.encoding_to_ascii[Int(value)])
         return out
 
     @always_inline

ishlib/parallel_fastx_search_runner.mojo

@@ -1,4 +1,3 @@
-from ExtraMojo.io import MovableWriter
 from ExtraMojo.io.buffered import BufferedWriter
 
 from time.time import perf_counter
@@ -62,22 +61,22 @@ struct ParallelFastxSearchRunner[M: Matcher]:
     var matcher: M
 
     fn run_search[
-        W: MovableWriter
+        W: Movable & Writer
     ](mut self, mut writer: BufferedWriter[W]) raises:
         # Peek only the first file to determine fastq or not, assume not-binary
         var peek = peek_file[record_type = RecordType.FASTX](
             self.settings.files[0]
         )
         for file in self.settings.files:
-            var f = file[]  # force copy
+            var f = file  # force copy
             Logger.debug("Processing", f)
             if peek.is_fastq:
                 self.run_search_on_file[is_fastq=True](f, writer)
             else:
                 self.run_search_on_file[is_fastq=False](f, writer)
 
     fn run_search_on_file[
-        W: MovableWriter, *, is_fastq: Bool = False
+        W: Movable & Writer, *, is_fastq: Bool = False
     ](mut self, file: Path, mut writer: BufferedWriter[W]) raises:
         # TODO: pass an enocoder to the FastaReader
         var reader = FastxReader[read_comment=False](
@@ -198,7 +197,7 @@ struct GpuParallelFastxSearchRunner[
         self.matcher = matcher
 
     fn run_search[
-        W: MovableWriter
+        W: Movable & Writer
     ](mut self, mut writer: BufferedWriter[W]) raises:
         # Peek the first file to get the suggested size, then use that for all of them.
         # Assume non-binary
@@ -254,7 +253,7 @@ struct GpuParallelFastxSearchRunner[
         return ctxs
 
     fn search_files[
-        W: MovableWriter,
+        W: Movable & Writer,
         max_query_length: UInt = 200,
         max_target_length: UInt = 1024,
     ](
@@ -283,7 +282,7 @@ struct GpuParallelFastxSearchRunner[
                 ](f, ctxs, writer)
 
     fn run_search_on_file[
-        W: MovableWriter,
+        W: Movable & Writer,
         max_query_length: UInt = 200,
         max_target_length: UInt = 1024,
         *,