Fix line ending handling in reverse_readfile/readline across OS, and not skipping empty lines

.github/workflows/test.yml

@@ -6,6 +6,7 @@ jobs:
   build:
     strategy:
       max-parallel: 20
+      fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-14, windows-latest]
         python-version: ["3.9", "3.x"]
@@ -29,6 +30,6 @@ jobs:
         run: pytest --cov=monty --cov-report html:coverage_reports tests
 
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v4
         env:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

src/monty/io.py

@@ -22,7 +22,7 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import IO, Generator, Union
+    from typing import IO, Generator, Literal, Union
 
 
 def zopen(filename: Union[str, Path], *args, **kwargs) -> IO:
@@ -54,7 +54,10 @@ def zopen(filename: Union[str, Path], *args, **kwargs) -> IO:
     return open(filename, *args, **kwargs)
 
 
-def reverse_readfile(filename: Union[str, Path]) -> Generator[str, str, None]:
+def reverse_readfile(
+    filename: Union[str, Path],
+    l_end: Literal["AUTO"] | str = "AUTO",
+) -> Generator[str, str, None]:
     """
     A much faster reverse read of file by using Python's mmap to generate a
     memory-mapped file. It is slower for very small files than
@@ -63,29 +66,38 @@ def reverse_readfile(filename: Union[str, Path]) -> Generator[str, str, None]:
 
     Args:
         filename (str | Path): File to read.
+        l_end ("AUTO" | str): Line ending. Use "AUTO" to
+            automatically decide line ending based on OS.
 
     Yields:
         Lines from the file in reverse order.
     """
+    # Generate line ending
+    l_end = os.linesep if "AUTO" else l_end
+
     try:
         with zopen(filename, "rb") as file:
             if isinstance(file, (gzip.GzipFile, bz2.BZ2File)):
                 for line in reversed(file.readlines()):
-                    yield line.decode("utf-8").rstrip(os.linesep)
+                    yield line.decode("utf-8").rstrip()
+
             else:
                 filemap = mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_READ)
                 n = len(filemap)
                 while n > 0:
-                    i = filemap.rfind(os.linesep.encode(), 0, n)
-                    yield filemap[i + 1 : n].decode("utf-8").rstrip(os.linesep)
+                    i = filemap.rfind(l_end.encode(), 0, n)
+                    yield filemap[i + 1 : n].decode("utf-8").rstrip()
                     n = i
 
     except ValueError:
         return
 
 
 def reverse_readline(
-    m_file, blk_size: int = 4096, max_mem: int = 4000000
+    m_file,
+    blk_size: int = 4096,
+    max_mem: int = 4000000,
+    l_end: Literal["AUTO"] | str = "AUTO",
 ) -> Generator[str, str, None]:
     """
     Generator function to read a file line-by-line, but backwards.
@@ -109,12 +121,17 @@ def reverse_readline(
             operation. This is used to determine when to reverse a file
             in-memory versus seeking portions of a file. For bz2 files,
             this sets the maximum block size.
+        l_end ("AUTO" | str): Line ending. Use "AUTO" to
+            automatically decide line ending based on OS.
 
     Returns:
         Generator that yields lines from the file. Behave similarly to the
         file.readline() function, except the lines are returned from the back
         of the file.
     """
+    # Generate line ending
+    l_end = os.linesep if "AUTO" else l_end
+
     # Check if the file stream is a bit stream or not
     is_text = isinstance(m_file, io.TextIOWrapper)
 
@@ -142,17 +159,17 @@ def reverse_readline(
         m_file.seek(0, 2)
         lastchar = m_file.read(1) if is_text else m_file.read(1).decode("utf-8")
 
-        trailing_newline = lastchar == os.linesep
+        trailing_newline = lastchar == l_end
 
         while True:
-            newline_pos = buf.rfind(os.linesep)
+            newline_pos = buf.rfind(l_end)
             pos = m_file.tell()
             if newline_pos != -1:
                 # Found a newline
                 line = buf[newline_pos + 1 :]
                 buf = buf[:newline_pos]
                 if pos or newline_pos or trailing_newline:
-                    line += os.linesep
+                    line += l_end
                 yield line
 
             elif pos:
@@ -165,7 +182,7 @@ def reverse_readline(
                     buf = m_file.read(toread).decode("utf-8") + buf
                 m_file.seek(pos - toread, 0)
                 if pos == toread:
-                    buf = os.linesep + buf
+                    buf = l_end + buf
 
             else:
                 # Start-of-file