Merge branch 'main' into john-performance

Author: johnpalsberg

README.md

@@ -28,7 +28,7 @@ There are several things in this repository:
 `mygfa` and `slow_odgi`
 -----------------------
 
-The `mygfa` library is an extremely simple Python library for representing (and parsing and emitting) GFA files. It emphasizes clarify over efficiency. Use `pip install mygfa` to get started, and read the [API documentation][mygfa-docs] for details.
+The `mygfa` library is an extremely simple Python library for representing (and parsing and emitting) GFA files. It emphasizes clarity over efficiency. Use `pip install mygfa` to get started, and read the [API documentation][mygfa-docs] for details.
 
 Similarly, `slow_odgi` is a set of GFA analyses based on `mygfa`; it's meant to act as a *reference implementation* of the much faster functionality in [odgi][]. Check out [the slow_odgi README](slow_odgi/) for more details.
 

flatgfa-py/src/lib.rs

@@ -42,7 +42,7 @@ impl Store {
     }
 
     /// Get the FlatGFA stored here.
-    fn view(&self) -> FlatGFA {
+    fn view(&self) -> FlatGFA<'_> {
         // TK It seems wasteful to check the type of store every time... and to construct
         // the view every time. It's probably possible to fix this with a self-reference,
         // e.g., with the `owning_ref` crate.

flatgfa/src/cli/cmds.rs

@@ -14,20 +14,40 @@ use std::io::Write;
 /// print the FlatGFA table of contents
 #[derive(FromArgs, PartialEq, Debug)]
 #[argh(subcommand, name = "toc")]
-pub struct Toc {}
-
-pub fn toc(gfa: &flatgfa::FlatGFA) {
-    eprintln!("header: {}", gfa.header.len());
-    eprintln!("segs: {}", gfa.segs.len());
-    eprintln!("paths: {}", gfa.paths.len());
-    eprintln!("links: {}", gfa.links.len());
-    eprintln!("steps: {}", gfa.steps.len());
-    eprintln!("seq_data: {}", gfa.seq_data.len());
-    eprintln!("overlaps: {}", gfa.overlaps.len());
-    eprintln!("alignment: {}", gfa.alignment.len());
-    eprintln!("name_data: {}", gfa.name_data.len());
-    eprintln!("optional_data: {}", gfa.optional_data.len());
-    eprintln!("line_order: {}", gfa.line_order.len());
+pub struct Toc {
+    /// show sizes in bytes instead of element counts
+    #[argh(switch, short = 'b')]
+    bytes: bool,
+}
+
+pub fn toc(gfa: &flatgfa::FlatGFA, args: Toc) {
+    if args.bytes {
+        // Show sizes in bytes.
+        println!("header: {}", gfa.header.size());
+        println!("segs: {}", gfa.segs.size());
+        println!("paths: {}", gfa.paths.size());
+        println!("links: {}", gfa.links.size());
+        println!("steps: {}", gfa.steps.size());
+        println!("seq_data: {}", gfa.seq_data.size());
+        println!("overlaps: {}", gfa.overlaps.size());
+        println!("alignment: {}", gfa.alignment.size());
+        println!("name_data: {}", gfa.name_data.size());
+        println!("optional_data: {}", gfa.optional_data.size());
+        println!("line_order: {}", gfa.line_order.size());
+    } else {
+        // Show element counts (which is what we record physically in the TOC).
+        println!("header: {}", gfa.header.len());
+        println!("segs: {}", gfa.segs.len());
+        println!("paths: {}", gfa.paths.len());
+        println!("links: {}", gfa.links.len());
+        println!("steps: {}", gfa.steps.len());
+        println!("seq_data: {}", gfa.seq_data.len());
+        println!("overlaps: {}", gfa.overlaps.len());
+        println!("alignment: {}", gfa.alignment.len());
+        println!("name_data: {}", gfa.name_data.len());
+        println!("optional_data: {}", gfa.optional_data.len());
+        println!("line_order: {}", gfa.line_order.len());
+    }
 }
 
 /// list the paths

flatgfa/src/cli/main.rs

@@ -112,11 +112,16 @@ fn main() -> Result<(), &'static str> {
     };
 
     match args.command {
+<<<<<<< HEAD
         Some(Command::StatsFileSize(_)) => {
             cmds::stats_filesize(&gfa);
         }
         Some(Command::Toc(_)) => {
             cmds::toc(&gfa);
+=======
+        Some(Command::Toc(sub_args)) => {
+            cmds::toc(&gfa, sub_args);
+>>>>>>> main
         }
         Some(Command::Paths(_)) => {
             cmds::paths(&gfa);

flatgfa/src/file.rs

@@ -182,7 +182,7 @@ fn read_toc_mut(data: &mut [u8]) -> (&mut Toc, &mut [u8]) {
 }
 
 /// Get a FlatGFA backed by the data in a byte buffer.
-pub fn view(data: &[u8]) -> flatgfa::FlatGFA {
+pub fn view(data: &[u8]) -> flatgfa::FlatGFA<'_> {
     let (toc, rest) = read_toc(data);
 
     let (header, rest) = slice_prefix(rest, toc.header);
@@ -216,7 +216,7 @@ pub fn view(data: &[u8]) -> flatgfa::FlatGFA {
 fn slice_vec_prefix<T: FromBytes + IntoBytes>(
     data: &mut [u8],
     size: Size,
-) -> (SliceVec<T>, &mut [u8]) {
+) -> (SliceVec<'_, T>, &mut [u8]) {
     let (prefix, rest) = <[T]>::mut_from_prefix_with_elems(data, size.capacity).unwrap();
     let vec = SliceVec::from_slice_len(prefix, size.len);
     (vec, rest)
@@ -252,13 +252,13 @@ fn slice_store<'a>(data: &'a mut [u8], toc: &Toc) -> flatgfa::FixedGFAStore<'a>
 }
 
 /// Get a mutable FlatGFA `SliceStore` backed by a byte buffer.
-pub fn view_store(data: &mut [u8]) -> flatgfa::FixedGFAStore {
+pub fn view_store<'a>(data: &'a mut [u8]) -> flatgfa::FixedGFAStore<'a> {
     let (toc, rest) = read_toc_mut(data);
     slice_store(rest, toc)
 }
 
 /// Initialize a buffer with an empty FlatGFA store.
-pub fn init(data: &mut [u8], toc: Toc) -> (&mut Toc, flatgfa::FixedGFAStore) {
+pub fn init(data: &mut [u8], toc: Toc) -> (&mut Toc, flatgfa::FixedGFAStore<'_>) {
     // Write the table of contents.
     assert!(data.len() == toc.size());
     toc.write_to_prefix(data).unwrap();

flatgfa/src/flatbed.rs

@@ -69,7 +69,7 @@ impl<'a, P: StoreFamily<'a>> BEDStore<'a, P> {
         self.entries.add(BEDEntry { name, start, end })
     }
 
-    pub fn as_ref(&self) -> FlatBED {
+    pub fn as_ref(&self) -> FlatBED<'_> {
         FlatBED {
             name_data: self.name_data.as_ref(),
             entries: self.entries.as_ref(),
@@ -108,7 +108,7 @@ pub type HeapBEDStore = BEDStore<'static, HeapFamily>;
 
 type ParseResult<T> = Result<T, &'static str>;
 type PartialParseResult<'a, T> = ParseResult<(T, &'a [u8])>;
-fn parse_num<T: FromRadix10>(s: &[u8]) -> PartialParseResult<T> {
+fn parse_num<T: FromRadix10>(s: &[u8]) -> PartialParseResult<'_, T> {
     match T::from_radix_10(s) {
         (_, 0) => Err("expected number"),
         (num, used) => Ok((num, &s[used..])),

flatgfa/src/flatgfa.rs

@@ -363,7 +363,7 @@ impl<'a> FlatGFA<'a> {
     ///
     /// A handle is a a forward or backward traversal of a specific segment. This method
     /// gets the sequence in the orientation specified by the handle.
-    pub fn get_seq_oriented(&self, handle: Handle) -> Sequence {
+    pub fn get_seq_oriented(&self, handle: Handle) -> Sequence<'_> {
         let seg = self.get_handle_seg(handle);
         let seq_data = PackedSeqView::from_pool(self.seq_data, seg.seq);
         Sequence::new(seq_data, handle.orient())
@@ -401,7 +401,7 @@ impl<'a> FlatGFA<'a> {
     }
 
     /// Look up a CIGAR alignment.
-    pub fn get_alignment(&self, overlap: Span<AlignOp>) -> Alignment {
+    pub fn get_alignment(&self, overlap: Span<AlignOp>) -> Alignment<'_> {
         Alignment {
             ops: &self.alignment[overlap],
         }
@@ -584,7 +584,7 @@ impl<'a, P: StoreFamily<'a>> GFAStore<'a, P> {
     }
 
     /// Borrow a FlatGFA view of this data store.
-    pub fn as_ref(&self) -> FlatGFA {
+    pub fn as_ref(&self) -> FlatGFA<'_> {
         FlatGFA {
             header: self.header.as_ref(),
             segs: self.segs.as_ref(),

flatgfa/src/gfaline.rs

@@ -34,7 +34,7 @@ pub struct Path<'a> {
 }
 
 /// Parse a single line of a GFA file.
-pub fn parse_line(line: &[u8]) -> LineResult {
+pub fn parse_line(line: &[u8]) -> LineResult<'_> {
     if line.len() < 2 || line[1] != b'\t' {
         return Err("expected marker and tab");
     }
@@ -49,20 +49,20 @@ pub fn parse_line(line: &[u8]) -> LineResult {
 }
 
 /// Parse a header line, which looks like `H <data>`.
-fn parse_header(line: &[u8]) -> LineResult {
+fn parse_header(line: &[u8]) -> LineResult<'_> {
     Ok(Line::Header(line))
 }
 
 /// Parse a segment line, which looks like `S <name> <seq> <data>`.
-fn parse_seg(line: &[u8]) -> LineResult {
+fn parse_seg(line: &[u8]) -> LineResult<'_> {
     let (name, rest) = parse_num(line)?;
     let rest = parse_byte(rest, b'\t')?;
     let (seq, data) = parse_field(rest)?;
     Ok(Line::Segment(Segment { name, seq, data }))
 }
 
 /// Parse a link line, which looks like `L <from> <+-> <to> <+-> <CIGAR>`.
-fn parse_link(line: &[u8]) -> LineResult {
+fn parse_link(line: &[u8]) -> LineResult<'_> {
     let (from_seg, rest) = parse_num(line)?;
     let rest = parse_byte(rest, b'\t')?;
     let (from_orient, rest) = parse_orient(rest)?;
@@ -85,7 +85,7 @@ fn parse_link(line: &[u8]) -> LineResult {
 }
 
 /// Parse a path line, which looks like `P <name> <steps> <*|CIGARs>`.
-fn parse_path(line: &[u8]) -> LineResult {
+fn parse_path(line: &[u8]) -> LineResult<'_> {
     let (name, rest) = parse_field(line)?;
     let (steps, rest) = parse_field(rest)?;
     let (overlaps, rest) = parse_maybe_overlap_list(rest)?;
@@ -100,7 +100,7 @@ fn parse_path(line: &[u8]) -> LineResult {
 }
 
 /// Parse a *possible* overlap list, which may be `*` (empty).
-pub fn parse_maybe_overlap_list(s: &[u8]) -> PartialParseResult<Vec<Vec<AlignOp>>> {
+pub fn parse_maybe_overlap_list(s: &[u8]) -> PartialParseResult<'_, Vec<Vec<AlignOp>>> {
     if s == b"*" {
         Ok((vec![], &s[1..]))
     } else {
@@ -111,7 +111,7 @@ pub fn parse_maybe_overlap_list(s: &[u8]) -> PartialParseResult<Vec<Vec<AlignOp>
 /// Parse a comma-separated list of CIGAR strings.
 ///
 /// TODO: This could be optimized to avoid accumulating into a vector.
-fn parse_overlap_list(s: &[u8]) -> PartialParseResult<Vec<Vec<AlignOp>>> {
+fn parse_overlap_list(s: &[u8]) -> PartialParseResult<'_, Vec<Vec<AlignOp>>> {
     let mut rest = s;
     let mut overlaps = vec![];
     while !rest.is_empty() {
@@ -126,7 +126,7 @@ fn parse_overlap_list(s: &[u8]) -> PartialParseResult<Vec<Vec<AlignOp>>> {
 }
 
 /// Consume a chunk of a string up to a given marker byte.
-fn parse_until(line: &[u8], marker: u8) -> PartialParseResult<&[u8]> {
+fn parse_until(line: &[u8], marker: u8) -> PartialParseResult<'_, &[u8]> {
     let end = memchr::memchr(marker, line).unwrap_or(line.len());
     let rest = if end == line.len() {
         &[]
@@ -137,7 +137,7 @@ fn parse_until(line: &[u8], marker: u8) -> PartialParseResult<&[u8]> {
 }
 
 /// Consume a string from the line, until a tab (or the end of the line).
-pub fn parse_field(line: &[u8]) -> PartialParseResult<&[u8]> {
+pub fn parse_field(line: &[u8]) -> PartialParseResult<'_, &[u8]> {
     parse_until(line, b'\t')
 }
 
@@ -150,15 +150,15 @@ fn parse_byte(s: &[u8], byte: u8) -> ParseResult<&[u8]> {
 }
 
 /// Parse a single integer.
-fn parse_num<T: FromRadix10>(s: &[u8]) -> PartialParseResult<T> {
+fn parse_num<T: FromRadix10>(s: &[u8]) -> PartialParseResult<'_, T> {
     match T::from_radix_10(s) {
         (_, 0) => Err("expected number"),
         (num, used) => Ok((num, &s[used..])),
     }
 }
 
 /// Parse a segment orientation (+ or -).
-fn parse_orient(line: &[u8]) -> PartialParseResult<Orientation> {
+fn parse_orient(line: &[u8]) -> PartialParseResult<'_, Orientation> {
     if line.is_empty() {
         return Err("expected orientation");
     }
@@ -171,7 +171,7 @@ fn parse_orient(line: &[u8]) -> PartialParseResult<Orientation> {
 }
 
 /// Parse a single CIGAR alignment operation (like `4D`).
-fn parse_align_op(s: &[u8]) -> PartialParseResult<AlignOp> {
+fn parse_align_op(s: &[u8]) -> PartialParseResult<'_, AlignOp> {
     let (len, rest) = parse_num::<u32>(s)?;
     let op = match rest[0] {
         b'M' => crate::flatgfa::AlignOpcode::Match,
@@ -186,7 +186,7 @@ fn parse_align_op(s: &[u8]) -> PartialParseResult<AlignOp> {
 /// Parse a complete CIGAR alignment string (like `3M2I`).
 ///
 /// TODO This could be optimized to avoid collecting into a vector.
-fn parse_align(s: &[u8]) -> PartialParseResult<Vec<AlignOp>> {
+fn parse_align(s: &[u8]) -> PartialParseResult<'_, Vec<AlignOp>> {
     let mut rest = s;
     let mut align = vec![];
     while !rest.is_empty() && rest[0].is_ascii_digit() {

flatgfa/src/memfile.rs

@@ -38,7 +38,7 @@ pub struct MemchrSplit<'a> {
 }
 
 impl MemchrSplit<'_> {
-    pub fn new(needle: u8, haystack: &[u8]) -> MemchrSplit {
+    pub fn new(needle: u8, haystack: &[u8]) -> MemchrSplit<'_> {
         MemchrSplit {
             needle,
             haystack,

flatgfa/src/packedseq.rs

@@ -385,8 +385,7 @@ impl PackedSeqStore {
         }
     }
 
-    /// Creates a PackedSeqView with the same data as this PackedSeqStore
-    pub fn as_ref(&self) -> PackedSeqView {
+    pub fn as_ref(&self) -> PackedSeqView<'_> {
         PackedSeqView {
             data: &self.data,
             high_nibble_end: self.high_nibble_end,