snakemake/io.py (3)

1754-1758: Consider using asyncio.gather for concurrent size retrieval.

The current implementation awaits each file size sequentially. For better performance, consider using asyncio.gather to retrieve file sizes concurrently.

-    def size_files(self):
-        async def sizes():
-            return [await f.size() for f in self]
+    def size_files(self):
+        async def sizes():
+            return await asyncio.gather(*(f.size() for f in self))

---

1760-1771: Enhance clarity and maintainability of size conversion properties.

Consider the following improvements:

1. Use constants for size conversion factors
2. Use floating-point division for more precise results
3. Add docstrings to document the units

+    # Constants for size conversions
+    _BYTES_IN_KB = 1024.0
+    _BYTES_IN_MB = _BYTES_IN_KB * 1024.0
+    _BYTES_IN_GB = _BYTES_IN_MB * 1024.0

     @property
     def size_files_kb(self):
+        """Returns a list of file sizes in kilobytes."""
-        return [f / 1024 for f in self.size_files]
+        return [f / self._BYTES_IN_KB for f in self.size_files]

     @property
     def size_files_mb(self):
+        """Returns a list of file sizes in megabytes."""
-        return [f / 1024 for f in self.size_files_kb]
+        return [f / self._BYTES_IN_MB for f in self.size_files]

     @property
     def size_files_gb(self):
+        """Returns a list of file sizes in gigabytes."""
-        return [f / 1024 for f in self.size_files_mb]
+        return [f / self._BYTES_IN_GB for f in self.size_files]

---

1772-1786: Enhance clarity and consistency of total size properties.

Consider adding docstrings and using the same constants for direct conversion from bytes.

     @property
     def size(self):
+        """Returns the total size in bytes."""
         return sum(self.size_files)

     @property
     def size_kb(self):
+        """Returns the total size in kilobytes."""
-        return sum(self.size_files_kb)
+        return self.size / self._BYTES_IN_KB

     @property
     def size_mb(self):
+        """Returns the total size in megabytes."""
-        return sum(self.size_files_mb)
+        return self.size / self._BYTES_IN_MB

     @property
     def size_gb(self):
+        """Returns the total size in gigabytes."""
-        return sum(self.size_files_gb)
+        return self.size / self._BYTES_IN_GB

Configuration used: CodeRabbit UI
Review profile: CHILL

snakemake/io.py (7)

1775-1780: Consider concurrent file-size retrieval to improve scalability.

Currently, the code awaits each file size in sequence within the sizes() coroutine, which can become slow for a large set of files. Leveraging concurrent tasks (e.g., asyncio.gather) inside sizes() would reduce total wait time.

A possible approach (shown as a diff example):

 def size_files(self):
     async def sizes():
-        return [await f.size() for f in self]
+        tasks = [asyncio.create_task(f.size()) for f in self]
+        return await asyncio.gather(*tasks)
     return async_run(sizes())

---

1781-1784: Use a named constant for clarity when converting to kilobytes.

Dividing by 1024 in multiple places works, but introducing a local constant (e.g., KB_FACTOR = 1024) can improve readability and maintainability.

---

1785-1788: Avoid repeated 1024-based divisions for MB calculations.

Since MB is just KB/1024, repeated divisions might introduce minor floating-point precision drift. Using a single step (e.g., size_in_mb = size_in_bytes / (1024**2)) can be clearer.

---

1789-1792: Consider a single-step conversion for GB.

As with MB, using a single-step approach for GB can make the conversion more explicit (e.g., (f / 1024**3)) and slightly reduce the risk of floating-point drift from multiple divisions.

---

1793-1796: Cache or store the total size to avoid repeated async calls.

Each property call to size_files triggers a new asynchronous retrieval. Summing again in size leads to repeated I/O. Caching the result (e.g., via a memoized approach) can improve performance if size is repeatedly accessed.

---

1797-1799: Consider memoizing the total size in KB.

Similar to size, calling size_files_kb reruns asynchronous lookups. A shared cached result or lazy evaluation would prevent recalculations on subsequent property accesses.

---

1805-1807: Add dedicated tests for GB calculations.

As a continuation of the above point, including checks for edge cases in size_gb (e.g., empty files or very large files) would foster confidence in the correctness of these conversions.

Would you like help drafting these additional test cases?

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro