Address PR review: drop unused imports, centralize zstandard import, tidy test helper

- Remove the unused create_tar_zst helper (dead since the gzip version) and
  the unused create_tar_zst/compress_log imports in WriterManager; drop the
  now-unused tarfile import in utils.
- Add require_zstandard() which lazily imports zstandard and raises a clear,
  actionable error when the optional dependency is missing; use it from
  compress_file_zstd and WriterManager.compress_dir.
- Make the test's _zstd_read_text helper self-contained (local import) and
  close the stream reader via a context manager.

Author: claude

src/tracer/WriterManager.py

@@ -30,8 +30,8 @@
 
 from .ObjectStorageManager import ObjectStorageManager
 from ..utility.utils import (
-    logger, create_tar_zst, capture_machine_id, compress_log,
-    compress_file_zstd, ZSTD_LEVEL,
+    logger, capture_machine_id,
+    compress_file_zstd, require_zstandard, ZSTD_LEVEL,
 )
 import threading
 from collections import deque
@@ -955,7 +955,7 @@ def compress_dir(self, input_dir: str):
             input_dir: Path to the directory to compress
         """
         try:
-            import zstandard
+            zstandard = require_zstandard()
             src = input_dir
             dst = input_dir.rstrip("/").rstrip("\\") + ".tar.zst"
 

src/utility/utils.py

@@ -27,7 +27,6 @@
 import os
 import time
 import datetime
-import tarfile
 import hashlib
 import socket
 import struct
@@ -197,6 +196,24 @@ def logger(error_scale: str, string: str, timestamp: bool = False):
 ZSTD_LEVEL = 3
 
 
+def require_zstandard():
+    """
+    Import and return the optional ``zstandard`` module.
+
+    Imported lazily so environments that never compress (and the pure-Python
+    unit tests) don't need the dependency at import time. Raises a clear,
+    actionable error if it is missing.
+    """
+    try:
+        import zstandard
+    except ModuleNotFoundError as e:
+        raise ModuleNotFoundError(
+            "The 'zstandard' library is required for Zstandard compression but "
+            "is not installed. Install it with 'pip install zstandard'."
+        ) from e
+    return zstandard
+
+
 def compress_file_zstd(src: str, dst: str, level: int = ZSTD_LEVEL):
     """
     Stream-compress a file to Zstandard.
@@ -205,35 +222,13 @@ def compress_file_zstd(src: str, dst: str, level: int = ZSTD_LEVEL):
         src: Path to the source file
         dst: Path to write the compressed (.zst) output
         level: Zstandard compression level
-
-    zstandard is imported lazily so environments that never compress (and the
-    pure-Python unit tests) don't require the dependency at import time.
     """
-    import zstandard
+    zstandard = require_zstandard()
     cctx = zstandard.ZstdCompressor(level=level)
     with open(src, "rb") as f_in, open(dst, "wb") as f_out:
         cctx.copy_stream(f_in, f_out)
 
 
-def create_tar_zst(output_filename: str, files_to_archive: list[str], level: int = ZSTD_LEVEL):
-    """
-    Create a Zstandard-compressed tar archive from a list of files.
-
-    Args:
-        output_filename: Name of the output .tar.zst file
-        files_to_archive: List of file paths to include
-        level: Zstandard compression level
-    """
-    import zstandard
-    cctx = zstandard.ZstdCompressor(level=level)
-    with open(output_filename, "wb") as f_out:
-        with cctx.stream_writer(f_out) as compressor:
-            with tarfile.open(mode="w|", fileobj=compressor) as tar:
-                for file_path in files_to_archive:
-                    tar.add(file_path, arcname=os.path.basename(file_path))
-    logger("info", f"Created tar.zst archive: {output_filename}")
-
-
 def compress_log(input_file: str):
     """
     Compress a log file using Zstandard.

tests/test_writer_upload.py

@@ -39,9 +39,10 @@
 
 def _zstd_read_text(path):
     """Decompress a .zst file to text for round-trip assertions."""
+    import zstandard
     dctx = zstandard.ZstdDecompressor()
-    with open(path, "rb") as f:
-        return dctx.stream_reader(f).read().decode()
+    with open(path, "rb") as f, dctx.stream_reader(f) as reader:
+        return reader.read().decode()
 
 
 from src.tracer.WriterManager import WriteManager