cargo fmt to format code

unipept · Sep 12, 2024 · 4be9148 · 4be9148
1 parent 7e17bd6
commit 4be9148
Show file tree

Hide file tree

Showing 24 changed files with 243 additions and 224 deletions.
diff --git a/bitarray/src/binary.rs b/bitarray/src/binary.rs
@@ -167,10 +167,13 @@ mod tests {
         let mut buffer = Vec::new();
         bitarray.write_binary(&mut buffer).unwrap();
 
-        assert_eq!(buffer, vec![
-            0xef, 0xcd, 0xab, 0x90, 0x78, 0x56, 0x34, 0x12, 0xde, 0xbc, 0x0a, 0x89, 0x67, 0x45, 0x23, 0x01, 0x00, 0x00,
-            0x00, 0x00, 0x56, 0x34, 0x12, 0xf0
-        ]);
+        assert_eq!(
+            buffer,
+            vec![
+                0xef, 0xcd, 0xab, 0x90, 0x78, 0x56, 0x34, 0x12, 0xde, 0xbc, 0x0a, 0x89, 0x67, 0x45, 0x23, 0x01, 0x00,
+                0x00, 0x00, 0x00, 0x56, 0x34, 0x12, 0xf0
+            ]
+        );
     }
 
     #[test]

diff --git a/bitarray/src/lib.rs b/bitarray/src/lib.rs
@@ -4,7 +4,7 @@ mod binary;
 
 use std::{
     cmp::max,
-    io::{Result, Write}
+    io::{Result, Write},
 };
 
 /// Re-export the `Binary` trait.
@@ -147,7 +147,6 @@ impl BitArray {
     pub fn get_data_slice(&self, start_slice: usize, end_slice: usize) -> &[u64] {
         &self.data[start_slice..end_slice]
     }
-
 }
 
 /// Writes the data to a writer in a binary format using a bit array. This function is helpfull
@@ -168,7 +167,7 @@ pub fn data_to_writer(
     data: Vec<i64>,
     bits_per_value: usize,
     max_capacity: usize,
-    writer: &mut impl Write
+    writer: &mut impl Write,
 ) -> Result<()> {
     // Update the max capacity to be a multiple of the greatest common divisor of the bits per value
     // and 64. This is done to ensure that the bit array can store the data entirely
@@ -312,10 +311,13 @@ mod tests {
 
         data_to_writer(data, 40, 2, &mut writer).unwrap();
 
-        assert_eq!(writer, vec![
-            0xef, 0xcd, 0xab, 0x90, 0x78, 0x56, 0x34, 0x12, 0xde, 0xbc, 0x0a, 0x89, 0x67, 0x45, 0x23, 0x01, 0x00, 0x00,
-            0x00, 0x00, 0x56, 0x34, 0x12, 0xf0
-        ]);
+        assert_eq!(
+            writer,
+            vec![
+                0xef, 0xcd, 0xab, 0x90, 0x78, 0x56, 0x34, 0x12, 0xde, 0xbc, 0x0a, 0x89, 0x67, 0x45, 0x23, 0x01, 0x00,
+                0x00, 0x00, 0x00, 0x56, 0x34, 0x12, 0xf0
+            ]
+        );
     }
 
     #[test]
@@ -334,23 +336,27 @@ mod tests {
 
         data_to_writer(data, 32, 8, &mut writer).unwrap();
 
-        assert_eq!(writer, vec![
-            0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11, 0x44, 0x44, 0x44, 0x44, 0x33, 0x33, 0x33, 0x33, 0x66, 0x66,
-            0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x88, 0x88, 0x88, 0x88, 0x77, 0x77, 0x77, 0x77, 0xaa, 0xaa, 0xaa, 0xaa,
-            0x99, 0x99, 0x99, 0x99, 0xcc, 0xcc, 0xcc, 0xcc, 0xbb, 0xbb, 0xbb, 0xbb, 0xee, 0xee, 0xee, 0xee, 0xdd, 0xdd,
-            0xdd, 0xdd, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11,
-            0x44, 0x44, 0x44, 0x44, 0x33, 0x33, 0x33, 0x33, 0x66, 0x66, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x88, 0x88,
-            0x88, 0x88, 0x77, 0x77, 0x77, 0x77, 0xaa, 0xaa, 0xaa, 0xaa, 0x99, 0x99, 0x99, 0x99, 0xcc, 0xcc, 0xcc, 0xcc,
-            0xbb, 0xbb, 0xbb, 0xbb, 0xee, 0xee, 0xee, 0xee, 0xdd, 0xdd, 0xdd, 0xdd, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
-            0xff, 0xff, 0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11, 0x44, 0x44, 0x44, 0x44, 0x33, 0x33, 0x33, 0x33,
-            0x66, 0x66, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x88, 0x88, 0x88, 0x88, 0x77, 0x77, 0x77, 0x77, 0xaa, 0xaa,
-            0xaa, 0xaa, 0x99, 0x99, 0x99, 0x99, 0xcc, 0xcc, 0xcc, 0xcc, 0xbb, 0xbb, 0xbb, 0xbb, 0xee, 0xee, 0xee, 0xee,
-            0xdd, 0xdd, 0xdd, 0xdd, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x22, 0x22, 0x22, 0x11, 0x11,
-            0x11, 0x11, 0x44, 0x44, 0x44, 0x44, 0x33, 0x33, 0x33, 0x33, 0x66, 0x66, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55,
-            0x88, 0x88, 0x88, 0x88, 0x77, 0x77, 0x77, 0x77, 0xaa, 0xaa, 0xaa, 0xaa, 0x99, 0x99, 0x99, 0x99, 0xcc, 0xcc,
-            0xcc, 0xcc, 0xbb, 0xbb, 0xbb, 0xbb, 0xee, 0xee, 0xee, 0xee, 0xdd, 0xdd, 0xdd, 0xdd, 0x00, 0x00, 0x00, 0x00,
-            0xff, 0xff, 0xff, 0xff
-        ]);
+        assert_eq!(
+            writer,
+            vec![
+                0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11, 0x44, 0x44, 0x44, 0x44, 0x33, 0x33, 0x33, 0x33, 0x66,
+                0x66, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x88, 0x88, 0x88, 0x88, 0x77, 0x77, 0x77, 0x77, 0xaa, 0xaa,
+                0xaa, 0xaa, 0x99, 0x99, 0x99, 0x99, 0xcc, 0xcc, 0xcc, 0xcc, 0xbb, 0xbb, 0xbb, 0xbb, 0xee, 0xee, 0xee,
+                0xee, 0xdd, 0xdd, 0xdd, 0xdd, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x22, 0x22, 0x22,
+                0x11, 0x11, 0x11, 0x11, 0x44, 0x44, 0x44, 0x44, 0x33, 0x33, 0x33, 0x33, 0x66, 0x66, 0x66, 0x66, 0x55,
+                0x55, 0x55, 0x55, 0x88, 0x88, 0x88, 0x88, 0x77, 0x77, 0x77, 0x77, 0xaa, 0xaa, 0xaa, 0xaa, 0x99, 0x99,
+                0x99, 0x99, 0xcc, 0xcc, 0xcc, 0xcc, 0xbb, 0xbb, 0xbb, 0xbb, 0xee, 0xee, 0xee, 0xee, 0xdd, 0xdd, 0xdd,
+                0xdd, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11,
+                0x44, 0x44, 0x44, 0x44, 0x33, 0x33, 0x33, 0x33, 0x66, 0x66, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x88,
+                0x88, 0x88, 0x88, 0x77, 0x77, 0x77, 0x77, 0xaa, 0xaa, 0xaa, 0xaa, 0x99, 0x99, 0x99, 0x99, 0xcc, 0xcc,
+                0xcc, 0xcc, 0xbb, 0xbb, 0xbb, 0xbb, 0xee, 0xee, 0xee, 0xee, 0xdd, 0xdd, 0xdd, 0xdd, 0x00, 0x00, 0x00,
+                0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11, 0x44, 0x44, 0x44, 0x44,
+                0x33, 0x33, 0x33, 0x33, 0x66, 0x66, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x88, 0x88, 0x88, 0x88, 0x77,
+                0x77, 0x77, 0x77, 0xaa, 0xaa, 0xaa, 0xaa, 0x99, 0x99, 0x99, 0x99, 0xcc, 0xcc, 0xcc, 0xcc, 0xbb, 0xbb,
+                0xbb, 0xbb, 0xee, 0xee, 0xee, 0xee, 0xdd, 0xdd, 0xdd, 0xdd, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+                0xff
+            ]
+        );
     }
 
     #[test]
@@ -365,16 +371,20 @@ mod tests {
 
         data_to_writer(data, 32, 8, &mut writer).unwrap();
 
-        assert_eq!(writer, vec![
-            0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11, 0x44, 0x44, 0x44, 0x44, 0x33, 0x33, 0x33, 0x33, 0x66, 0x66,
-            0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x88, 0x88, 0x88, 0x88, 0x77, 0x77, 0x77, 0x77, 0xaa, 0xaa, 0xaa, 0xaa,
-            0x99, 0x99, 0x99, 0x99, 0xcc, 0xcc, 0xcc, 0xcc, 0xbb, 0xbb, 0xbb, 0xbb, 0xee, 0xee, 0xee, 0xee, 0xdd, 0xdd,
-            0xdd, 0xdd, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11,
-            0x44, 0x44, 0x44, 0x44, 0x33, 0x33, 0x33, 0x33, 0x66, 0x66, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x88, 0x88,
-            0x88, 0x88, 0x77, 0x77, 0x77, 0x77, 0xaa, 0xaa, 0xaa, 0xaa, 0x99, 0x99, 0x99, 0x99, 0xcc, 0xcc, 0xcc, 0xcc,
-            0xbb, 0xbb, 0xbb, 0xbb, 0xee, 0xee, 0xee, 0xee, 0xdd, 0xdd, 0xdd, 0xdd, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
-            0xff, 0xff, 0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11, 0x00, 0x00, 0x00, 0x00, 0x33, 0x33, 0x33, 0x33
-        ]);
+        assert_eq!(
+            writer,
+            vec![
+                0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11, 0x44, 0x44, 0x44, 0x44, 0x33, 0x33, 0x33, 0x33, 0x66,
+                0x66, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x88, 0x88, 0x88, 0x88, 0x77, 0x77, 0x77, 0x77, 0xaa, 0xaa,
+                0xaa, 0xaa, 0x99, 0x99, 0x99, 0x99, 0xcc, 0xcc, 0xcc, 0xcc, 0xbb, 0xbb, 0xbb, 0xbb, 0xee, 0xee, 0xee,
+                0xee, 0xdd, 0xdd, 0xdd, 0xdd, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x22, 0x22, 0x22,
+                0x11, 0x11, 0x11, 0x11, 0x44, 0x44, 0x44, 0x44, 0x33, 0x33, 0x33, 0x33, 0x66, 0x66, 0x66, 0x66, 0x55,
+                0x55, 0x55, 0x55, 0x88, 0x88, 0x88, 0x88, 0x77, 0x77, 0x77, 0x77, 0xaa, 0xaa, 0xaa, 0xaa, 0x99, 0x99,
+                0x99, 0x99, 0xcc, 0xcc, 0xcc, 0xcc, 0xbb, 0xbb, 0xbb, 0xbb, 0xee, 0xee, 0xee, 0xee, 0xdd, 0xdd, 0xdd,
+                0xdd, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11,
+                0x00, 0x00, 0x00, 0x00, 0x33, 0x33, 0x33, 0x33
+            ]
+        );
     }
 
     #[test]

diff --git a/fa-compression/benches/algorithm1/decode.rs b/fa-compression/benches/algorithm1/decode.rs
@@ -22,7 +22,7 @@ pub fn decode_benchmark(c: &mut criterion::Criterion) {
         b.iter_batched(
             || generate_encoded_annotations(100),
             |annotations| black_box(decode(annotations.as_slice())),
-            criterion::BatchSize::SmallInput
+            criterion::BatchSize::SmallInput,
         )
     });
 }
diff --git a/fa-compression/benches/algorithm1/encode.rs b/fa-compression/benches/algorithm1/encode.rs
@@ -22,7 +22,7 @@ pub fn encode_benchmark(c: &mut criterion::Criterion) {
         b.iter_batched(
             || generate_decoded_annotations(100),
             |annotations| black_box(encode(annotations.as_str())),
-            criterion::BatchSize::SmallInput
+            criterion::BatchSize::SmallInput,
         )
     });
 }
diff --git a/fa-compression/benches/algorithm2/decode.rs b/fa-compression/benches/algorithm2/decode.rs
@@ -28,7 +28,7 @@ pub fn decode_benchmark(c: &mut criterion::Criterion) {
         b.iter_batched(
             || generate_encoded_annotations_and_table(100),
             |(annotations, ct)| black_box(decode(annotations.as_slice(), ct)),
-            criterion::BatchSize::SmallInput
+            criterion::BatchSize::SmallInput,
         )
     });
 }
diff --git a/fa-compression/benches/algorithm2/encode.rs b/fa-compression/benches/algorithm2/encode.rs
@@ -26,7 +26,7 @@ pub fn encode_benchmark(c: &mut criterion::Criterion) {
         b.iter_batched(
             || generate_decoded_annotations_and_table(100),
             |(annotations, ct)| black_box(encode(annotations.as_str(), ct)),
-            criterion::BatchSize::SmallInput
+            criterion::BatchSize::SmallInput,
         )
     });
 }
diff --git a/fa-compression/benches/util.rs b/fa-compression/benches/util.rs
@@ -27,6 +27,6 @@ pub fn generate_annotation(random: &mut ThreadRng) -> String {
         0 => generate_ipr(random),
         1 => generate_go(random),
         2 => generate_ec(random),
-        _ => unreachable!()
+        _ => unreachable!(),
     }
 }
diff --git a/fa-compression/src/algorithm1/encode.rs b/fa-compression/src/algorithm1/encode.rs
@@ -106,16 +106,18 @@ mod tests {
 
     #[test]
     fn test_encode_no_ec() {
-        assert_eq!(encode("IPR:IPR016364;GO:0009279;IPR:IPR008816"), vec![
-            225, 17, 163, 138, 225, 39, 71, 95, 17, 153, 39
-        ])
+        assert_eq!(
+            encode("IPR:IPR016364;GO:0009279;IPR:IPR008816"),
+            vec![225, 17, 163, 138, 225, 39, 71, 95, 17, 153, 39]
+        )
     }
 
     #[test]
     fn test_encode_no_go() {
-        assert_eq!(encode("IPR:IPR016364;EC:1.1.1.-;EC:1.2.1.7"), vec![
-            44, 44, 44, 191, 44, 60, 44, 142, 225, 39, 71, 80
-        ])
+        assert_eq!(
+            encode("IPR:IPR016364;EC:1.1.1.-;EC:1.2.1.7"),
+            vec![44, 44, 44, 191, 44, 60, 44, 142, 225, 39, 71, 80]
+        )
     }
 
     #[test]
@@ -125,8 +127,9 @@ mod tests {
 
     #[test]
     fn test_encode_all() {
-        assert_eq!(encode("IPR:IPR016364;EC:1.1.1.-;IPR:IPR032635;GO:0009279;IPR:IPR008816"), vec![
-            44, 44, 44, 190, 17, 26, 56, 174, 18, 116, 117, 241, 67, 116, 111, 17, 153, 39
-        ])
+        assert_eq!(
+            encode("IPR:IPR016364;EC:1.1.1.-;IPR:IPR032635;GO:0009279;IPR:IPR008816"),
+            vec![44, 44, 44, 190, 17, 26, 56, 174, 18, 116, 117, 241, 67, 116, 111, 17, 153, 39]
+        )
     }
 }
diff --git a/fa-compression/src/algorithm1/mod.rs b/fa-compression/src/algorithm1/mod.rs
@@ -79,7 +79,7 @@ enum CharacterSet {
     Comma,
 
     /// Annotation separator
-    Semicolon
+    Semicolon,
 }
 
 impl Encode for CharacterSet {
@@ -110,7 +110,7 @@ impl Encode for CharacterSet {
             b'n' => CharacterSet::Preliminary,
             b',' => CharacterSet::Comma,
             b';' => CharacterSet::Semicolon,
-            _ => panic!("Invalid character")
+            _ => panic!("Invalid character"),
         }
     }
 }
@@ -143,7 +143,7 @@ impl Decode for CharacterSet {
             13 => 'n',
             14 => ',',
             15 => ';',
-            _ => panic!("Invalid character")
+            _ => panic!("Invalid character"),
         }
     }
 }
@@ -189,7 +189,7 @@ mod tests {
         CharacterSet::Point,
         CharacterSet::Preliminary,
         CharacterSet::Comma,
-        CharacterSet::Semicolon
+        CharacterSet::Semicolon,
     ];
 
     #[test]

diff --git a/fa-compression/src/algorithm2/encode.rs b/fa-compression/src/algorithm2/encode.rs
@@ -89,8 +89,9 @@ mod tests {
     #[test]
     fn test_encode_all() {
         let table = create_compresion_table();
-        assert_eq!(encode("IPR:IPR000001;EC:1.1.1.-;IPR:IPR000003;GO:0000002", table), vec![
-            0, 0, 0, 7, 0, 0, 2, 0, 0, 5, 0, 0
-        ])
+        assert_eq!(
+            encode("IPR:IPR000001;EC:1.1.1.-;IPR:IPR000003;GO:0000002", table),
+            vec![0, 0, 0, 7, 0, 0, 2, 0, 0, 5, 0, 0]
+        )
     }
 }
diff --git a/fa-compression/src/algorithm2/mod.rs b/fa-compression/src/algorithm2/mod.rs
@@ -12,13 +12,13 @@ pub use encode::encode;
 /// Represents an entry in the compression table.
 #[doc(hidden)]
 pub struct CompressionTableEntry {
-    annotation: String
+    annotation: String,
 }
 
 /// Represents a compression table.
 pub struct CompressionTable {
     /// List of annotations in the compression table.
-    entries: Vec<CompressionTableEntry>
+    entries: Vec<CompressionTableEntry>,
 }
 
 impl CompressionTable {

diff --git a/libsais64-rs/builder.rs b/libsais64-rs/builder.rs
@@ -3,14 +3,14 @@ use std::{
     error::Error,
     fmt::{Display, Formatter},
     path::{Path, PathBuf},
-    process::{Command, ExitStatus}
+    process::{Command, ExitStatus},
 };
 
 /// Custom error for compilation of the C library
 #[derive(Debug)]
 struct CompileError<'a> {
     command: &'a str,
-    exit_code: Option<i32>
+    exit_code: Option<i32>,
 }
 
 impl<'a> Display for CompileError<'a> {
@@ -43,7 +43,7 @@ impl<'a> Error for CompileError<'a> {}
 fn exit_status_to_result(name: &str, exit_status: ExitStatus) -> Result<(), CompileError> {
     match exit_status.success() {
         true => Ok(()),
-        false => Err(CompileError { command: name, exit_code: exit_status.code() })
+        false => Err(CompileError { command: name, exit_code: exit_status.code() }),
     }
 }
 
@@ -61,7 +61,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     Command::new("rm").args(["libsais/CMakeCache.txt"]).status().unwrap_or_default(); // if removing fails, it is since the cmake cache did not exist, we just can ignore it
     exit_status_to_result(
         "cmake",
-        Command::new("cmake").args(["-DCMAKE_BUILD_TYPE=\"Release\"", "libsais", "-Blibsais"]).status()?
+        Command::new("cmake").args(["-DCMAKE_BUILD_TYPE=\"Release\"", "libsais", "-Blibsais"]).status()?,
     )?;
     exit_status_to_result("make", Command::new("make").args(["-C", "libsais"]).status()?)?;
 

diff --git a/libsais64-rs/src/lib.rs b/libsais64-rs/src/lib.rs
@@ -16,7 +16,11 @@ include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
 pub fn sais64(text: &[u8]) -> Option<Vec<i64>> {
     let mut sa = vec![0; text.len()];
     let exit_code = unsafe { libsais64(text.as_ptr(), sa.as_mut_ptr(), text.len() as i64, 0, std::ptr::null_mut()) };
-    if exit_code == 0 { Some(sa) } else { None }
+    if exit_code == 0 {
+        Some(sa)
+    } else {
+        None
+    }
 }
 
 #[cfg(test)]

diff --git a/sa-builder/src/lib.rs b/sa-builder/src/lib.rs
@@ -21,14 +21,14 @@ pub struct Arguments {
     pub construction_algorithm: SAConstructionAlgorithm,
     /// If the suffix array should be compressed (default value true)
     #[arg(short, long, default_value_t = false)]
-    pub compress_sa: bool
+    pub compress_sa: bool,
 }
 
 /// Enum representing the two possible algorithms to construct the suffix array
 #[derive(ValueEnum, Clone, Debug, PartialEq)]
 pub enum SAConstructionAlgorithm {
     LibDivSufSort,
-    LibSais
+    LibSais,
 }
 
 /// Build a sparse suffix array from the given text
@@ -48,15 +48,15 @@ pub enum SAConstructionAlgorithm {
 pub fn build_ssa(
     text: &mut Vec<u8>,
     construction_algorithm: &SAConstructionAlgorithm,
-    sparseness_factor: u8
+    sparseness_factor: u8,
 ) -> Result<Vec<i64>, Box<dyn Error>> {
     // translate all L's to a I
     translate_l_to_i(text);
 
     // Build the suffix array using the selected algorithm
     let mut sa = match construction_algorithm {
         SAConstructionAlgorithm::LibSais => libsais64_rs::sais64(text),
-        SAConstructionAlgorithm::LibDivSufSort => libdivsufsort_rs::divsufsort64(text)
+        SAConstructionAlgorithm::LibDivSufSort => libdivsufsort_rs::divsufsort64(text),
     }
     .ok_or("Building suffix array failed")?;
 
@@ -125,7 +125,7 @@ mod tests {
             "2",
             "--construction-algorithm",
             "lib-div-suf-sort",
-            "--compress-sa"
+            "--compress-sa",
         ]);
 
         assert_eq!(args.database_file, "database.fa");

diff --git a/sa-builder/src/main.rs b/sa-builder/src/main.rs
@@ -1,7 +1,7 @@
 use std::{
     fs::{File, OpenOptions},
     io::BufWriter,
-    time::{SystemTime, SystemTimeError, UNIX_EPOCH}
+    time::{SystemTime, SystemTimeError, UNIX_EPOCH},
 };
 
 use clap::Parser;
@@ -16,7 +16,7 @@ fn main() {
         output,
         sparseness_factor,
         construction_algorithm,
-        compress_sa
+        compress_sa,
     } = Arguments::parse();
     eprintln!();
     eprintln!("📋 Started loading the proteins...");