PyArchiveFile 0.24.2__py3-none-any.whl → 0.24.6__py3-none-any.whl

pyarchivefile.py

@@ -14,7 +14,7 @@
     Copyright 2018-2024 Game Maker 2k - http://intdb.sourceforge.net/
     Copyright 2018-2024 Kazuki Przyborowski - https://github.com/KazukiPrzyborowski
 
-    $FileInfo: pyarchivefile.py - Last Update: 10/31/2025 Ver. 0.24.2 RC 1 - Author: cooldude2k $
+    $FileInfo: pyarchivefile.py - Last Update: 11/3/2025 Ver. 0.24.6 RC 1 - Author: cooldude2k $
 '''
 
 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
@@ -33,10 +33,10 @@ import socket
 import struct
 import hashlib
 import inspect
-import datetime
 import logging
 import zipfile
 import binascii
+import datetime
 import platform
 from io import StringIO, BytesIO
 from collections import namedtuple
@@ -413,7 +413,12 @@ def is_only_nonprintable(var):
 __file_format_multi_dict__ = {}
 __file_format_default__ = "ArchiveFile"
 __include_defaults__ = True
-__use_inmemfile__ = False
+__use_inmemfile__ = True
+__use_spoolfile__ = False
+__use_spooldir__ = tempfile.gettempdir()
+BYTES_PER_MiB = 1024 * 1024
+DEFAULT_SPOOL_MAX = 8 * BYTES_PER_MiB
+__spoolfile_size__ = DEFAULT_SPOOL_MAX
 __program_name__ = "Py"+__file_format_default__
 __use_env_file__ = True
 __use_ini_file__ = True
@@ -450,6 +455,8 @@ if __use_ini_file__ and os.path.exists(__config_file__):
     __program_name__ = decode_unicode_escape(config.get('config', 'proname'))
     __include_defaults__ = config.getboolean('config', 'includedef')
     __use_inmemfile__ = config.getboolean('config', 'inmemfile')
+    __use_spoolfile__ = config.getboolean('config', 'usespoolfile')
+    __spoolfile_size__ = config.getint('config', 'spoolfilesize')
     # Loop through all sections
     for section in config.sections():
         if section == "config":
@@ -543,6 +550,8 @@ elif __use_json_file__ and os.path.exists(__config_file__):
     __program_name__        = decode_unicode_escape(_get(cfg_config, 'proname', ''))
     __include_defaults__    = _to_bool(_get(cfg_config, 'includedef', False))
     __use_inmemfile__       = _to_bool(_get(cfg_config, 'inmemfile', False))
+    __use_spoolfile__       = _to_bool(_get(cfg_config, 'usespoolfile', False))
+    __spoolfile_size__       = _to_int(_get(cfg_config, 'spoolfilesize', DEFAULT_SPOOL_MAX))
 
     # --- iterate format sections (everything except "config") ---
     required_keys = [
@@ -622,13 +631,15 @@ __use_alt_inode__ = __file_format_multi_dict__[__file_format_default__]['use_alt
 __file_format_extension__ = __file_format_multi_dict__[__file_format_default__]['format_extension']
 __file_format_dict__ = __file_format_multi_dict__[__file_format_default__]
 __project__ = __program_name__
+__program_alt_name__ = __program_name__
 __project_url__ = "https://github.com/GameMaker2k/PyArchiveFile"
-__version_info__ = (0, 24, 2, "RC 1", 1)
-__version_date_info__ = (2025, 10, 31, "RC 1", 1)
+__project_release_url__ = __project_url__+"/releases/latest"
+__version_info__ = (0, 24, 6, "RC 1", 1)
+__version_date_info__ = (2025, 11, 3, "RC 1", 1)
 __version_date__ = str(__version_date_info__[0]) + "." + str(
     __version_date_info__[1]).zfill(2) + "." + str(__version_date_info__[2]).zfill(2)
 __revision__ = __version_info__[3]
-__revision_id__ = "$Id: 62e42aa44d2836eb3c32bec6badb12ea21c1ebc3 $"
+__revision_id__ = "$Id: 45d7adad4e0436f23599e18a9fb332d3724fa26d $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -640,6 +651,78 @@ if(__version_info__[3] is not None):
 if(__version_info__[3] is None):
     __version__ = str(__version_info__[0]) + "." + str(__version_info__[1]) + "." + str(__version_info__[2])
 
+# From: https://stackoverflow.com/a/28568003
+# By Phaxmohdem
+
+
+def versiontuple(v):
+    filled = []
+    for point in v.split("."):
+        filled.append(point.zfill(8))
+    return tuple(filled)
+
+
+def version_check(myvercheck, newvercheck):
+    vercheck = 0
+    try:
+        from packaging import version
+        vercheck = 1
+    except ImportError:
+        try:
+            from distutils.version import LooseVersion, StrictVersion
+            vercheck = 2
+        except ImportError:
+            try:
+                from pkg_resources import parse_version
+                vercheck = 3
+            except ImportError:
+                return 5
+    # print(myvercheck, newvercheck)
+    if (vercheck == 1):
+        if (version.parse(myvercheck) == version.parse(newvercheck)):
+            return 0
+        elif (version.parse(myvercheck) < version.parse(newvercheck)):
+            return 1
+        elif (version.parse(myvercheck) > version.parse(newvercheck)):
+            return 2
+        else:
+            return 3
+    elif (vercheck == 2):
+        if (StrictVersion(myvercheck) == StrictVersion(newvercheck)):
+            return 0
+        elif (StrictVersion(myvercheck) < StrictVersion(newvercheck)):
+            return 1
+        elif (StrictVersion(myvercheck) > StrictVersion(newvercheck)):
+            return 2
+        else:
+            return 3
+    elif (vercheck == 3):
+        if (parse_version(myvercheck) == parse_version(newvercheck)):
+            return 0
+        elif (parse_version(myvercheck) < parse_version(newvercheck)):
+            return 1
+        elif (parse_version(myvercheck) > parse_version(newvercheck)):
+            return 2
+        else:
+            return 3
+    else:
+        if (versiontuple(myvercheck) == versiontuple(newvercheck)):
+            return 0
+        elif (versiontuple(myvercheck) < versiontuple(newvercheck)):
+            return 1
+        elif (versiontuple(myvercheck) > versiontuple(newvercheck)):
+            return 2
+        else:
+            return 3
+    return 4
+
+
+def check_version_number(myversion=__version__, proname=__program_alt_name__, newverurl=__project_release_url__):
+    prevercheck = download_from_url(newverurl, geturls_headers, geturls_cj)
+    newvercheck = re.findall(proname + " ([0-9\\.]+)<\\/a\\>", prevercheck['Content'].decode("UTF-8"))[0]
+    myvercheck = re.findall("([0-9\\.]+)", myversion)[0]
+    return version_check(myvercheck, newvercheck)
+
 # ===== Module-level type code table & helpers (reuse anywhere) =====
 
 FT = {
@@ -740,6 +823,7 @@ try:
     compressionsupport.append("lz4")
 except ImportError:
     pass
+'''
 try:
     import lzo
     compressionsupport.append("lzo")
@@ -747,6 +831,7 @@ try:
 except ImportError:
     lzo = None
     pass
+'''
 try:
     import zstandard
     compressionsupport.append("zst")
@@ -806,11 +891,13 @@ if('lzo' in compressionsupport):
     compressionlistalt.append('lzo')
     outextlist.append('lzo')
     outextlistwd.append('.lzo')
+'''
 if('lzop' in compressionsupport):
     compressionlist.append('lzop')
     compressionlistalt.append('lzop')
     outextlist.append('lzop')
     outextlistwd.append('.lzop')
+'''
 if('lzma' in compressionsupport):
     compressionlist.append('lzma')
     compressionlistalt.append('lzma')
@@ -1956,7 +2043,7 @@ def _normalize_initial_data(data, isbytes, encoding, errors=None):
 
 
 def MkTempFile(data=None,
-               inmem=True,
+               inmem=__use_inmemfile__,
                isbytes=True,
                prefix="",
                delete=True,
@@ -1964,9 +2051,9 @@ def MkTempFile(data=None,
                newline=None,      # text mode only; in-memory objects ignore newline semantics
                dir=None,
                suffix="",
-               use_spool=False,
-               spool_max=8 * 1024 * 1024,
-               spool_dir=None):
+               use_spool=__use_spoolfile__,
+               spool_max=__spoolfile_size__,
+               spool_dir=__use_spooldir__):
     """
     Return a file-like handle with consistent behavior on Py2.7 and Py3.x.
 
@@ -2409,7 +2496,7 @@ class ZlibFile(object):
 
     def __init__(self, file_path=None, fileobj=None, mode='rb', level=6, wbits=15,
                  encoding=None, errors=None, newline=None,
-                 tolerant_read=False, scan_bytes=(64 << 10), spool_threshold=(8 << 20)):
+                 tolerant_read=False, scan_bytes=(64 << 10), spool_threshold=__spoolfile_size__):
 
         if file_path is None and fileobj is None:
             raise ValueError("Either file_path or fileobj must be provided")
@@ -2896,7 +2983,7 @@ class GzipFile(object):
 
     def __init__(self, file_path=None, fileobj=None, mode='rb',
                  level=6, encoding=None, errors=None, newline=None,
-                 tolerant_read=False, scan_bytes=(64 << 10), spool_threshold=(8 << 20)):
+                 tolerant_read=False, scan_bytes=(64 << 10), spool_threshold=__spoolfile_size__):
 
         if file_path is None and fileobj is None:
             raise ValueError("Either file_path or fileobj must be provided")
@@ -3320,519 +3407,6 @@ def gzip_decompress_bytes_all_members(blob):
     """
     return _gzip_decompress_multimember(bytes(blob))
 
-
-# ---------- Simple LZO container (NOT real .lzop) ----------
-# File layout (concatenated members allowed):
-# [MAGIC 8B] [FLAGS 1B] [ULEN 8B] [CRC32 4B] [CCHUNK...]  | repeat...
-# where:
-#   MAGIC  = b'\x89LZO\x0D\x0A\x1A\n'
-#   FLAGS  = bit0: 1 => member has ULEN+CRC, 0 => no header (legacy)
-#   ULEN   = uncompressed length (u64 BE)
-#   CRC32  = CRC32 of uncompressed data (u32 BE)
-#   CCHUNK = one or more compressed chunks:
-#              [u32BE chunk_size][chunk_data] ... then a zero-size u32 terminator
-
-
-class LzopFile(object):
-    MAGIC = b'\x89LZO\x0D\x0A\x1A\n'
-    FLAG_HAS_UHDR = 0x01
-    RAW_CHUNK = 256 * 1024  # 256 KiB per raw (pre-compress) chunk
-
-    def __init__(self, file_path=None, fileobj=None, mode='rb',
-                 level=9, encoding=None, errors=None, newline=None,
-                 write_header=True,
-                 tolerant_read=False, scan_bytes=(64 << 10),
-                 spool_threshold=(8 << 20)):
-        """
-        Custom LZO file (NOT the lzop(1) format).
-        - streaming write/read, supports concatenated members
-        - optional per-member header (uncompressed length + CRC32)
-        - spooled reads to limit RAM, strict text mode with newline control
-        - tolerant_read: scan forward (up to scan_bytes) to first MAGIC
-
-        :param write_header: if True, include ULEN+CRC32 per member
-        :param tolerant_read: skip leading junk up to scan_bytes to find MAGIC
-        :param scan_bytes: max bytes to scan when tolerant_read=True
-        :param spool_threshold: SpooledTemporaryFile RAM threshold before spill
-        """
-        if lzo is None:
-            raise ImportError("python-lzo is required for LzopFile")
-
-        if file_path is None and fileobj is None:
-            raise ValueError("Either file_path or fileobj must be provided")
-        if file_path is not None and fileobj is not None:
-            raise ValueError("Only one of file_path or fileobj should be provided")
-
-        if 'b' not in mode and 't' not in mode:
-            mode += 'b'
-        if 'x' in mode and PY2:
-            raise ValueError("Exclusive creation mode 'x' is not supported on Python 2")
-
-        self.file_path = file_path
-        self.file = fileobj
-        self.mode = mode
-        self.level = int(level)  # effective: 1 or 9 (clamped)
-        self.encoding = encoding
-        self.errors = errors
-        self.newline = newline
-        self._text_mode = ('t' in mode)
-
-        self._write_header = bool(write_header)
-
-        # Config (read path)
-        self.tolerant_read = bool(tolerant_read)
-        self.scan_bytes = int(scan_bytes)
-        self.spool_threshold = int(spool_threshold)
-
-        # Write state
-        self._crc = 0
-        self._ulen = 0
-        self._open_member = False
-        self._member_header_pos = None  # position *after* ULEN+CRC placeholders
-
-        # Read state
-        self._spool = None
-        self._text_reader = None
-        self._position = 0
-        self.closed = False
-
-        internal_mode = mode.replace('t', 'b')
-        if self.file is None:
-            if 'x' in internal_mode and os.path.exists(file_path):
-                raise IOError("File exists: '{}'".format(file_path))
-            self.file = open(file_path, internal_mode)
-        else:
-            if 'r' in internal_mode and not hasattr(self.file, 'read'):
-                raise ValueError("fileobj must support read() in read mode")
-            if any(ch in internal_mode for ch in ('w', 'a', 'x')) and not hasattr(self.file, 'write'):
-                raise ValueError("fileobj must support write() in write/append mode")
-
-        self._fp = self.file
-        if any(ch in internal_mode for ch in ('w', 'a', 'x')):
-            # Start a new member at EOF for append
-            if 'a' in internal_mode:
-                try:
-                    self.file.seek(0, os.SEEK_END)
-                except Exception:
-                    pass
-            # Defer writing header until first write so empty files don’t get empty members
-        elif 'r' in internal_mode:
-            self._load_all_members_spooled()
-        else:
-            raise ValueError("Unsupported mode: {}".format(mode))
-
-    # ---------- helpers ----------
-    @property
-    def name(self):
-        return self.file_path
-
-    def readable(self):
-        return 'r' in self.mode
-
-    def writable(self):
-        return any(ch in self.mode for ch in ('w', 'a', 'x'))
-
-    def seekable(self):
-        return True if self._spool is not None else bool(getattr(self.file, 'seek', None))
-
-    def _normalize_newlines_for_write(self, s):
-        nl = self.newline if self.newline is not None else "\n"
-        return s.replace("\r\n", "\n").replace("\r", "\n").replace("\n", nl)
-
-    def _reader(self):
-        return self._text_reader if self._text_mode else self._spool
-
-    # ---------- Write path ----------
-    def _ensure_member_header(self):
-        if self._open_member:
-            return
-        flags = self.FLAG_HAS_UHDR if self._write_header else 0
-        self.file.write(self.MAGIC)
-        self.file.write(struct.pack(">B", flags))
-        if self._write_header:
-            # placeholders for ULEN+CRC; we’ll backfill on finalize
-            self.file.write(struct.pack(">Q", 0))
-            self.file.write(struct.pack(">I", 0))
-        # position *after* ULEN+CRC placeholders (or after FLAGS if no header)
-        self._member_header_pos = self.file.tell()
-        self._open_member = True
-        # reset member stats
-        self._crc = 0
-        self._ulen = 0
-
-    def write(self, data):
-        if 'r' in self.mode:
-            raise IOError("File not open for writing")
-
-        if self._text_mode:
-            enc = self.encoding or 'UTF-8'
-            errs = self.errors or 'strict'
-            if not isinstance(data, text_type):
-                raise TypeError("write() expects text (unicode/str) in text mode")
-            data = self._normalize_newlines_for_write(data).encode(enc, errs)
-        else:
-            if not isinstance(data, binary_types):
-                raise TypeError("write() expects bytes-like in binary mode")
-
-        # Normalize Py3 memoryview / Py2 bytearray
-        if (not PY2) and isinstance(data, memoryview):
-            data = data.tobytes()
-        elif PY2 and isinstance(data, bytearray):
-            data = bytes(data)
-
-        if not data:
-            return 0
-
-        # Begin member and write header on first write
-        self._ensure_member_header()
-
-        # Update integrity stats
-        self._crc = _crc32u(data, self._crc)
-        self._ulen += len(data)
-
-        # Stream in RAW_CHUNK-sized pieces. Each piece becomes one compressed chunk record.
-        mv = memoryview(data)
-        # clamp level to {1, 9}
-        lvl = 9 if self.level >= 9 else 1
-        for off in range(0, len(data), self.RAW_CHUNK):
-            raw = mv[off:off + self.RAW_CHUNK].tobytes()
-            c = lzo.compress(raw, lvl)
-            self.file.write(struct.pack(">I", len(c)))
-            self.file.write(c)
-
-        return len(data)
-
-    def _flush_member_only(self):
-        """Finalize the current member: write terminator and backfill header."""
-        if not self._open_member:
-            return
-        # write zero-length chunk terminator
-        self.file.write(struct.pack(">I", 0))
-        if self._write_header:
-            # ULEN is at (_member_header_pos - 12), CRC at (_member_header_pos - 4)
-            ulen_pos = self._member_header_pos - 12
-            crc_pos = self._member_header_pos - 4
-            cur = self.file.tell()
-            # backfill ULEN
-            self.file.seek(ulen_pos, os.SEEK_SET)
-            self.file.write(struct.pack(">Q", self._ulen))
-            # backfill CRC32
-            self.file.seek(crc_pos, os.SEEK_SET)
-            self.file.write(struct.pack(">I", self._crc))
-            # restore position
-            self.file.seek(cur, os.SEEK_SET)
-        # reset for potential new member
-        self._open_member = False
-        self._crc = 0
-        self._ulen = 0
-        self._member_header_pos = None
-
-    def flush(self):
-        if self.closed:
-            return
-        # finalize any open member
-        if any(ch in self.mode for ch in ('w', 'a', 'x')) and self._open_member:
-            self._flush_member_only()
-        if hasattr(self.file, 'flush'):
-            self.file.flush()
-
-    def close(self):
-        if self.closed:
-            return
-        try:
-            # Ensure a clean member terminator & header backfill if needed
-            if any(ch in self.mode for ch in ('w', 'a', 'x')) and self._open_member:
-                self._flush_member_only()
-            if hasattr(self.file, 'flush'):
-                try:
-                    self.file.flush()
-                except Exception:
-                    pass
-        finally:
-            if self.file_path and self.file is not None:
-                try:
-                    self.file.close()
-                except Exception:
-                    pass
-            # tear down read handles
-            try:
-                if self._text_reader is not None:
-                    self._text_reader.detach()
-            except Exception:
-                pass
-            try:
-                if self._spool is not None:
-                    self._spool.close()
-            except Exception:
-                pass
-            self.closed = True
-
-    # ---------- Read path (spooled, multi-member, tolerant scan) ----------
-    def _load_all_members_spooled(self):
-        # Seek to start if possible
-        try:
-            self.file.seek(0)
-        except Exception:
-            pass
-
-        self._spool = tempfile.SpooledTemporaryFile(max_size=self.spool_threshold)
-
-        def read_exact(n, abs_off_ref):
-            """Read exactly n bytes, updating abs_off_ref[0]."""
-            b = b""
-            while len(b) < n:
-                part = self.file.read(n - len(b))
-                if not part:
-                    break
-                b += part
-                abs_off_ref[0] += len(part)
-            return b
-
-        CHUNK = 1 << 20
-        abs_off = [0]   # track absolute file offset
-        scanned = 0
-
-        while True:
-            # Locate MAGIC (support tolerant scan across chunk boundaries)
-            head = read_exact(len(self.MAGIC), abs_off)
-            if not head:
-                break  # EOF
-            if head != self.MAGIC:
-                # Tolerant scan: slide-by-one until found or limit exceeded
-                buf = head
-                while True:
-                    if self.tolerant_read and scanned < self.scan_bytes:
-                        nxt = read_exact(1, abs_off)
-                        if not nxt:
-                            # EOF without finding magic
-                            raise ValueError("Invalid LZO container: magic not found before EOF")
-                        buf = buf[1:] + nxt
-                        scanned += 1
-                        if buf == self.MAGIC:
-                            break
-                        continue
-                    raise ValueError("Invalid LZO container magic near offset {}".format(abs_off[0] - len(buf)))
-                # found MAGIC; proceed
-
-            # FLAGS
-            f_b = read_exact(1, abs_off)
-            if len(f_b) != 1:
-                raise ValueError("Truncated header (flags) at offset {}".format(abs_off[0]))
-            flags = ord(f_b) if PY2 else f_b[0]
-
-            # Optional ULEN/CRC
-            ulen = None
-            expect_crc = None
-            if flags & self.FLAG_HAS_UHDR:
-                ulen_b = read_exact(8, abs_off)
-                crc_b = read_exact(4, abs_off)
-                if len(ulen_b) != 8 or len(crc_b) != 4:
-                    raise ValueError("Truncated ULEN/CRC header at offset {}".format(abs_off[0]))
-                ulen = struct.unpack(">Q", ulen_b)[0]
-                expect_crc = struct.unpack(">I", crc_b)[0]
-
-            # Chunk loop
-            m_crc = 0
-            m_len = 0
-            while True:
-                sz_b = read_exact(4, abs_off)
-                if len(sz_b) != 4:
-                    raise ValueError("Truncated chunk size at offset {}".format(abs_off[0]))
-                csz = struct.unpack(">I", sz_b)[0]
-                if csz == 0:
-                    break  # end of member
-                cdata = read_exact(csz, abs_off)
-                if len(cdata) != csz:
-                    raise ValueError("Truncated chunk payload at offset {}".format(abs_off[0]))
-                try:
-                    raw = lzo.decompress(cdata)
-                except Exception as e:
-                    raise ValueError("LZO decompression error at offset {}: {}".format(abs_off[0], e))
-                self._spool.write(raw)
-                m_len += len(raw)
-                m_crc = _crc32u(raw, m_crc)
-
-            # Validate member integrity if header present
-            if ulen is not None and m_len != ulen:
-                raise ValueError("Member length mismatch ({} != {})".format(m_len, ulen))
-            if expect_crc is not None and m_crc != expect_crc:
-                raise ValueError("Member CRC32 mismatch (got 0x{:08x}, want 0x{:08x})"
-                                 .format(m_crc, expect_crc))
-
-        # Prepare read handles
-        try:
-            self._spool.seek(0)
-        except Exception:
-            pass
-
-        if self._text_mode:
-            enc = self.encoding or 'UTF-8'
-            errs = self.errors or 'strict'
-            # newline=None => universal newline translation; exact string if provided
-            self._text_reader = io.TextIOWrapper(self._spool, encoding=enc, errors=errs, newline=self.newline)
-            try:
-                self._text_reader.seek(0)
-            except Exception:
-                pass
-
-        self._position = 0
-
-    # ---------- Buffered read API (delegates to spool/text wrapper) ----------
-    def read(self, size=-1):
-        if self.closed:
-            raise ValueError("I/O operation on closed file")
-        if 'r' not in self.mode:
-            raise IOError("File not open for reading")
-        r = self._reader()
-        if r is None:
-            raise IOError("Reader not initialized")
-        out = r.read() if (size is None or size < 0) else r.read(int(size))
-        try:
-            self._position = r.tell()
-        except Exception:
-            pass
-        return out
-
-    def readline(self, size=-1):
-        if self.closed:
-            raise ValueError("I/O operation on closed file")
-        if 'r' not in self.mode:
-            raise IOError("File not open for reading")
-        r = self._reader()
-        if r is None:
-            raise IOError("Reader not initialized")
-        out = r.readline() if (size is None or size < 0) else r.readline(int(size))
-        try:
-            self._position = r.tell()
-        except Exception:
-            pass
-        if not self._text_mode and out is None:
-            return b""
-        if self._text_mode and out is None:
-            return text_type("")
-        return out
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        line = self.readline()
-        if (self._text_mode and line == "") or (not self._text_mode and line == b""):
-            raise StopIteration
-        return line
-
-    if PY2:
-        next = __next__
-
-    def seek(self, offset, whence=0):
-        if self.closed:
-            raise ValueError("I/O operation on closed file")
-        if 'r' not in self.mode:
-            raise IOError("File not open for reading")
-        r = self._reader()
-        if r is None:
-            raise IOError("Reader not initialized")
-        newpos = r.seek(int(offset), int(whence))
-        self._position = newpos
-        return newpos
-
-    def tell(self):
-        if self._reader() is not None:
-            try:
-                self._position = self._reader().tell()
-            except Exception:
-                pass
-        return self._position
-
-    # ---------- Misc ----------
-    def fileno(self):
-        if hasattr(self.file, 'fileno'):
-            return self.file.fileno()
-        raise OSError("Underlying file object does not support fileno()")
-
-    def isatty(self):
-        return bool(getattr(self.file, 'isatty', lambda: False)())
-
-    def truncate(self, size=None):
-        # Prevent corruption of compressed streams
-        raise OSError("truncate() is not supported for compressed streams")
-
-    # ---------- Convenience constructors ----------
-    @classmethod
-    def open(cls, path, mode='rb', **kw):
-        """
-        Mirror built-in open() but for LzopFile.
-        Example:
-            with LzopFile.open("data.lzo", "rt", encoding="utf-8") as f:
-                print(f.readline())
-        """
-        return cls(file_path=path, mode=mode, **kw)
-
-    @classmethod
-    def from_fileobj(cls, fileobj, mode='rb', **kw):
-        """
-        Wrap an existing file-like object (caller retains ownership).
-        """
-        return cls(fileobj=fileobj, mode=mode, **kw)
-
-    @classmethod
-    def from_bytes(cls, data, mode='rb', **kw):
-        """
-        Read from an in-memory bytes buffer.
-        Example:
-            f = LzopFile.from_bytes(blob, mode='rt', encoding='utf-8', tolerant_read=True)
-            text = f.read()
-        """
-        if not isinstance(data, (bytes, bytearray, memoryview)):
-            raise TypeError("from_bytes() expects a bytes-like object")
-        bio = io.BytesIO(bytes(data) if not isinstance(data, bytes) else data)
-        return cls(fileobj=bio, mode=mode, **kw)
-
-    # compatibility aliases for unwrapping utilities
-    @property
-    def fileobj(self):
-        return self.file
-
-    @property
-    def myfileobj(self):
-        return self.file
-
-# ---------- Top-level helpers ----------
-def lzop_compress_bytes(payload, level=9, text=False, **kw):
-    """
-    Compress 'payload' into a single LZO member (our custom container) and return bytes.
-    - text=True: 'payload' is text; encoding/newline/errors handled via LzopFile('wt')
-    - text=False: 'payload' is bytes-like; written via LzopFile('wb')
-    Kwargs forwarded: write_header (default True), newline/encoding/errors, etc.
-    """
-    bio = io.BytesIO()
-    mode = 'wt' if text else 'wb'
-    f = LzopFile(fileobj=bio, mode=mode, level=level, **kw)
-    try:
-        f.write(payload)
-        f.flush()  # finalize member (writes terminator + backfills header)
-    finally:
-        f.close()
-    return bio.getvalue()
-
-
-def lzop_decompress_bytes(blob, mode='rb', tolerant_read=False, scan_bytes=(64 << 10),
-                          spool_threshold=(8 << 20), **kw):
-    """
-    Decompress bytes produced by this custom container.
-    - mode='rb' -> returns bytes; mode='rt' -> returns text (set encoding/errors/newline in kw)
-    - tolerant_read/scan_bytes/spool_threshold forwarded to LzopFile
-    """
-    if not isinstance(blob, (bytes, bytearray, memoryview)):
-        raise TypeError("lzop_decompress_bytes() expects a bytes-like object")
-    f = LzopFile.from_bytes(blob, mode=mode, tolerant_read=tolerant_read,
-                            scan_bytes=scan_bytes, spool_threshold=spool_threshold, **kw)
-    try:
-        return f.read()
-    finally:
-        f.close()
-
-
 def TarFileCheck(infile):
     try:
         if is_tarfile(infile):
@@ -4088,6 +3662,49 @@ _CRC_SPECS = {
     "crc64_iso":   CRCSpec(64, 0x000000000000001B, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, True,  True),
 }
 
+# --- helpers --------------------------------------------------------------
+
+try:
+    # Python 2 may not have algorithms_available
+    _ALGORITHMS_AVAILABLE = set(hashlib.algorithms_available)
+except AttributeError:
+    _ALGORITHMS_AVAILABLE = set(getattr(hashlib, "algorithms", []))
+
+
+def _coerce_bytes(data):
+    """Return `data` as a bytes object (Py2 / Py3)."""
+    if isinstance(data, memoryview):
+        # Py3 has .tobytes(), Py2 falls back to bytes()
+        try:
+            return data.tobytes()
+        except AttributeError:
+            return bytes(data)
+
+    if isinstance(data, bytearray):
+        return bytes(data)
+
+    if not isinstance(data, bytes):
+        # E.g. list of ints, unicode, etc.
+        return bytes(bytearray(data))
+
+    return data
+
+
+def _bytes_to_int(b):
+    """Big-endian bytes -> int, Py2/3 safe."""
+    if not isinstance(b, (bytes, bytearray)):
+        b = _coerce_bytes(b)
+
+    value = 0
+    for ch in b:
+        if not isinstance(ch, int):  # Py2: ch is a 1-char string
+            ch = ord(ch)
+        value = (value << 8) | ch
+    return value
+
+
+# --- your existing CRCContext (unchanged) ---------------------------------
+
 class CRCContext(object):
     __slots__ = ("spec", "table", "mask", "shift", "crc")
 
@@ -4132,6 +3749,82 @@ class CRCContext(object):
         width_hex = (self.spec.width + 3) // 4
         return format(self.digest_int(), "0{}x".format(width_hex)).lower()
 
+
+# --- hashlib-backed implementation ---------------------------------------
+
+class _HashlibCRCWrapper(object):
+    """
+    Wrap a hashlib object to present the same interface as CRCContext
+    (update, digest_int, hexdigest).
+
+    Assumes the hashlib algorithm already implements the exact CRC
+    specification (refin/refout/xorout/etc.).
+    """
+    __slots__ = ("_h", "spec", "mask", "width_hex")
+
+    def __init__(self, algo_name, spec):
+        self._h = hashlib.new(algo_name)
+        self.spec = spec
+        self.mask = (1 << spec.width) - 1
+        self.width_hex = (spec.width + 3) // 4
+
+    def update(self, data):
+        self._h.update(_coerce_bytes(data))
+        return self
+
+    def digest_int(self):
+        # Convert final digest bytes to an integer and mask to width
+        value = _bytes_to_int(self._h.digest())
+        return value & self.mask
+
+    def hexdigest(self):
+        h = self._h.hexdigest().lower()
+        # Normalize to the same number of hex digits as CRCContext
+        if len(h) < self.width_hex:
+            h = ("0" * (self.width_hex - len(h))) + h
+        elif len(h) > self.width_hex:
+            h = h[-self.width_hex:]
+        return h
+
+
+# --- public class: choose hashlib or fallback -----------------------------
+
+class CRC(object):
+    """
+    CRC wrapper that uses hashlib if available, otherwise falls back to
+    the pure-Python CRCContext.
+
+    spec.hashlib_name (preferred) or spec.name is used as the hashlib
+    algorithm name, e.g. 'crc32', 'crc32c', etc.
+    """
+
+    __slots__ = ("spec", "_impl")
+
+    def __init__(self, spec):
+        self.spec = spec
+
+        algo_name = getattr(spec, "hashlib_name", None) or getattr(spec, "name", None)
+        impl = None
+
+        if algo_name and algo_name in _ALGORITHMS_AVAILABLE:
+            # Use hashlib-backed implementation
+            impl = _HashlibCRCWrapper(algo_name, spec)
+        else:
+            # Fallback to your pure-Python implementation
+            impl = CRCContext(spec)
+
+        self._impl = impl
+
+    def update(self, data):
+        self._impl.update(data)
+        return self
+
+    def digest_int(self):
+        return self._impl.digest_int()
+
+    def hexdigest(self):
+        return self._impl.hexdigest()
+
 def crc_context_from_name(name_norm):
     spec = _CRC_SPECS.get(name_norm)
     if spec is None:
@@ -5225,7 +4918,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
             cfcontents.close()
             fcontents.seek(0, 0)
             fccs = GetFileChecksum(
-                fcontents.read(), HeaderOut[-3].lower(), False, formatspecs)
+                fcontents, HeaderOut[-3].lower(), False, formatspecs)
     fcontentend = fp.tell()
     if(re.findall("^\\+([0-9]+)", fseeknextfile)):
         fseeknextasnum = int(fseeknextfile.replace("+", ""))
@@ -7083,9 +6776,9 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
         if(verbose):
             VerbosePrintOut(fname)
         if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
-            fpremode = int(stat.S_IFDIR + 511)
+            fpremode = int(stat.S_IFDIR | 0x1ff)
         else:
-            fpremode = int(stat.S_IFREG + 438)
+            fpremode = int(stat.S_IFREG | 0x1b6)
         flinkcount = 0
         ftype = 0
         if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
@@ -7114,37 +6807,42 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
         fbtime = format(
             int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower()
         if(zipinfo.create_system == 0 or zipinfo.create_system == 10):
-            fwinattributes = format(int(zipinfo.external_attr), 'x').lower()
+            fwinattributes = format(int(zipinfo.external_attr & 0xFFFF), 'x').lower()
             if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
-                fmode = format(int(stat.S_IFDIR + 511), 'x').lower()
-                fchmode = stat.S_IMODE(int(stat.S_IFDIR + 511))
-                ftypemod = stat.S_IFMT(int(stat.S_IFDIR + 511))
+                fmode = format(int(stat.S_IFDIR | 0x1ff), 'x').lower()
+                fchmode = stat.S_IMODE(int(stat.S_IFDIR | 0x1ff))
+                ftypemod = stat.S_IFMT(int(stat.S_IFDIR | 0x1ff))
             else:
-                fmode = format(int(stat.S_IFREG + 438), 'x').lower()
-                fchmode = stat.S_IMODE(int(stat.S_IFREG + 438))
-                ftypemod = stat.S_IFMT(int(stat.S_IFREG + 438))
+                fmode = format(int(stat.S_IFREG | 0x1b6), 'x').lower()
+                fchmode = stat.S_IMODE(int(stat.S_IFREG | 0x1b6))
+                ftypemod = stat.S_IFMT(int(stat.S_IFREG | 0x1b6))
         elif(zipinfo.create_system == 3):
-            fwinattributes = format(int(0), 'x').lower()
-            try:
-                fmode = format(int(zipinfo.external_attr), 'x').lower()
-                prefmode = int(zipinfo.external_attr)
-                fchmode = stat.S_IMODE(prefmode)
-                ftypemod = stat.S_IFMT(prefmode)
-            except OverflowError:
-                fmode = format(int(zipinfo.external_attr >> 16), 'x').lower()
-                prefmode = int(zipinfo.external_attr >> 16)
-                fchmode = stat.S_IMODE(prefmode)
-                ftypemod = stat.S_IFMT(prefmode)
-        else:
-            fwinattributes = format(int(0), 'x').lower()
+            fwinattributes = format(int(zipinfo.external_attr & 0xFFFF), 'x').lower()
+            fmode = format(int((zipinfo.external_attr >> 16) & 0xFFFF), 'x').lower()
+            prefmode = int((zipinfo.external_attr >> 16) & 0xFFFF)
+            if (prefmode == 0):
+                if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
+                    fmode = format(int(stat.S_IFDIR | 0x1ff), 'x').lower()
+                    prefmode = int(stat.S_IFDIR | 0x1ff)
+                    fchmode = stat.S_IMODE(prefmode)
+                    ftypemod = stat.S_IFMT(prefmode)
+                else:
+                    fmode = format(int(stat.S_IFREG | 0x1b6), 'x').lower()
+                    prefmode = int(stat.S_IFREG | 0x1b6)
+                    fchmode = stat.S_IMODE(prefmode)
+                    ftypemod = stat.S_IFMT(prefmode)
+            fchmode = stat.S_IMODE(prefmode)
+            ftypemod = stat.S_IFMT(prefmode)
+        else:
+            fwinattributes = format(int(zipinfo.external_attr & 0xFFFF), 'x').lower()
             if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
-                fmode = format(int(stat.S_IFDIR + 511), 'x').lower()
-                prefmode = int(stat.S_IFDIR + 511)
+                fmode = format(int(stat.S_IFDIR | 0x1ff), 'x').lower()
+                prefmode = int(stat.S_IFDIR | 0x1ff)
                 fchmode = stat.S_IMODE(prefmode)
                 ftypemod = stat.S_IFMT(prefmode)
             else:
-                fmode = format(int(stat.S_IFREG + 438), 'x').lower()
-                prefmode = int(stat.S_IFREG + 438)
+                fmode = format(int(stat.S_IFREG | 0x1b6), 'x').lower()
+                prefmode = int(stat.S_IFREG | 0x1b6)
                 fchmode = stat.S_IMODE(prefmode)
                 ftypemod = stat.S_IFMT(prefmode)
         fcompression = ""
@@ -7326,11 +7024,11 @@ if(rarfile_support):
             if(is_unix and member.external_attr != 0):
                 fpremode = int(member.external_attr)
             elif(member.is_file()):
-                fpremode = int(stat.S_IFREG + 438)
+                fpremode = int(stat.S_IFREG | 0x1b6)
             elif(member.is_symlink()):
-                fpremode = int(stat.S_IFLNK + 438)
+                fpremode = int(stat.S_IFLNK | 0x1b6)
             elif(member.is_dir()):
-                fpremode = int(stat.S_IFDIR + 511)
+                fpremode = int(stat.S_IFDIR | 0x1ff)
             if(is_windows and member.external_attr != 0):
                 fwinattributes = format(int(member.external_attr), 'x').lower()
             else:
@@ -7383,23 +7081,23 @@ if(rarfile_support):
                 ftypemod = format(
                     int(stat.S_IFMT(member.external_attr)), 'x').lower()
             elif(member.is_file()):
-                fmode = format(int(stat.S_IFREG + 438), 'x').lower()
+                fmode = format(int(stat.S_IFREG | 0x1b6), 'x').lower()
                 fchmode = format(
-                    int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower()
+                    int(stat.S_IMODE(int(stat.S_IFREG | 0x1b6))), 'x').lower()
                 ftypemod = format(
-                    int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower()
+                    int(stat.S_IFMT(int(stat.S_IFREG | 0x1b6))), 'x').lower()
             elif(member.is_symlink()):
-                fmode = format(int(stat.S_IFLNK + 438), 'x').lower()
+                fmode = format(int(stat.S_IFLNK | 0x1b6), 'x').lower()
                 fchmode = format(
-                    int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower()
+                    int(stat.S_IMODE(int(stat.S_IFREG | 0x1b6))), 'x').lower()
                 ftypemod = format(
-                    int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower()
+                    int(stat.S_IFMT(int(stat.S_IFREG | 0x1b6))), 'x').lower()
             elif(member.is_dir()):
-                fmode = format(int(stat.S_IFDIR + 511), 'x').lower()
+                fmode = format(int(stat.S_IFDIR | 0x1ff), 'x').lower()
                 fchmode = format(
-                    int(stat.S_IMODE(int(stat.S_IFDIR + 511))), 'x').lower()
+                    int(stat.S_IMODE(int(stat.S_IFDIR | 0x1ff))), 'x').lower()
                 ftypemod = format(
-                    int(stat.S_IFMT(int(stat.S_IFDIR + 511))), 'x').lower()
+                    int(stat.S_IFMT(int(stat.S_IFDIR | 0x1ff))), 'x').lower()
             try:
                 fuid = format(int(os.getuid()), 'x').lower()
             except AttributeError:
@@ -7503,11 +7201,11 @@ if(rarfile_support):
         return fp
 
 if(not py7zr_support):
-    def AppendFilesWithContentFromSevenZip(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["crc32", "crc32", "crc32", "crc32"], formatspecs=__file_format_dict__, verbose=False):
+    def AppendFilesWithContentFromSevenZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["crc32", "crc32", "crc32", "crc32"], formatspecs=__file_format_dict__, verbose=False):
         return False
 
 if(py7zr_support):
-    def AppendFilesWithContentFromSevenZip(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["crc32", "crc32", "crc32", "crc32"], formatspecs=__file_format_dict__, verbose=False):
+    def AppendFilesWithContentFromSevenZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["crc32", "crc32", "crc32", "crc32"], formatspecs=__file_format_dict__, verbose=False):
         if(not hasattr(fp, "write")):
             return False
         if(verbose):
@@ -7550,9 +7248,9 @@ if(py7zr_support):
             if(verbose):
                 VerbosePrintOut(fname)
             if(not member.is_directory):
-                fpremode = int(stat.S_IFREG + 438)
+                fpremode = int(stat.S_IFREG | 0x1b6)
             elif(member.is_directory):
-                fpremode = int(stat.S_IFDIR + 511)
+                fpremode = int(stat.S_IFDIR | 0x1ff)
             fwinattributes = format(int(0), 'x').lower()
             fcompression = ""
             fcsize = format(int(0), 'x').lower()
@@ -7576,17 +7274,17 @@ if(py7zr_support):
             fctime = format(int(member.creationtime.timestamp()), 'x').lower()
             fbtime = format(int(member.creationtime.timestamp()), 'x').lower()
             if(member.is_directory):
-                fmode = format(int(stat.S_IFDIR + 511), 'x').lower()
+                fmode = format(int(stat.S_IFDIR | 0x1ff), 'x').lower()
                 fchmode = format(
-                    int(stat.S_IMODE(int(stat.S_IFDIR + 511))), 'x').lower()
+                    int(stat.S_IMODE(int(stat.S_IFDIR | 0x1ff))), 'x').lower()
                 ftypemod = format(
-                    int(stat.S_IFMT(int(stat.S_IFDIR + 511))), 'x').lower()
+                    int(stat.S_IFMT(int(stat.S_IFDIR | 0x1ff))), 'x').lower()
             else:
-                fmode = format(int(stat.S_IFREG + 438), 'x').lower()
+                fmode = format(int(stat.S_IFREG | 0x1b6), 'x').lower()
                 fchmode = format(
-                    int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower()
+                    int(stat.S_IMODE(int(stat.S_IFREG | 0x1b6))), 'x').lower()
                 ftypemod = format(
-                    int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower()
+                    int(stat.S_IFMT(int(stat.S_IFREG | 0x1b6))), 'x').lower()
             try:
                 fuid = format(int(os.getuid()), 'x').lower()
             except AttributeError:
@@ -8225,11 +7923,11 @@ def AppendFilesWithContentFromRarFileToStackedOutFile(infiles, outfile, fmttype=
     return returnout
 
 if(not py7zr_support):
-    def AppendFilesWithContentFromSevenZipToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["crc32", "crc32", "crc32", "crc32"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+    def AppendFilesWithContentFromSevenZipFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["crc32", "crc32", "crc32", "crc32"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
         return False
 
 if(py7zr_support):
-    def AppendFilesWithContentFromSevenZipToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["crc32", "crc32", "crc32", "crc32"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+    def AppendFilesWithContentFromSevenZipFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["crc32", "crc32", "crc32", "crc32"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
         if(IsNestedDict(formatspecs) and fmttype=="auto" and 
             (outfile != "-" and outfile is not None and not hasattr(outfile, "read") and not hasattr(outfile, "write"))):
             get_in_ext = os.path.splitext(outfile)
@@ -8271,7 +7969,7 @@ if(py7zr_support):
                 fp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
             except PermissionError:
                 return False
-        AppendFilesWithContentFromSevenZip(infiles, fp, extradata, jsondata, compression,
+        AppendFilesWithContentFromSevenZipFile(infiles, fp, extradata, jsondata, compression,
                                        compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, verbose)
         if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = CompressOpenFileAlt(
@@ -8309,12 +8007,12 @@ if(py7zr_support):
             fp.close()
             return True
 
-def AppendFilesWithContentFromSevenZipToStackedOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["crc32", "crc32", "crc32", "crc32"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+def AppendFilesWithContentFromSevenZipFileToStackedOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["crc32", "crc32", "crc32", "crc32"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
     if not isinstance(infiles, list):
         infiles = [infiles]
     returnout = False
     for infileslist in infiles:
-        returnout = AppendFilesWithContentFromSevenZipToOutFile(infileslist, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, verbose, True)
+        returnout = AppendFilesWithContentFromSevenZipFileToOutFile(infileslist, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, verbose, True)
         if(not returnout):
             break
         else:
@@ -9018,8 +8716,6 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, file
                     fp = pyzstd.zstdfile.ZstdFile(infile, mode="rb")
                 else:
                     return Flase
-            elif((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
-                fp = LzopFile(infile, mode="rb")
             elif((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
                 fp = lzma.open(infile, "rb")
             elif(compresscheck == "zlib" and compresscheck in compressionsupport):
@@ -9142,8 +8838,6 @@ def UncompressFileAlt(fp, formatspecs=__file_format_multi_dict__, filestart=0,
             return False
     elif kind == "lz4"    and "lz4"    in compressionsupport:
         wrapped = lz4.frame.LZ4FrameFile(src, mode="rb")
-    elif kind in ("lzo","lzop") and (("lzo" in compressionsupport) or ("lzop" in compressionsupport)):
-        wrapped = LzopFile(fileobj=src, mode="rb")
     elif kind == "zlib"   and "zlib"   in compressionsupport:
         wrapped = ZlibFile(fileobj=src, mode="rb")
     else:
@@ -9215,8 +8909,6 @@ def UncompressFile(infile, formatspecs=__file_format_multi_dict__, mode="rb",
                 return False
         elif (compresscheck == "lz4" and "lz4" in compressionsupport):
             fp = lz4.frame.open(infile, mode)
-        elif ((compresscheck == "lzo" or compresscheck == "lzop") and "lzop" in compressionsupport):
-            fp = LzopFile(infile, mode=mode)
         elif ((compresscheck == "lzma" or compresscheck == "xz") and "xz" in compressionsupport):
             fp = lzma.open(infile, mode)
         elif (compresscheck == "zlib" and "zlib" in compressionsupport):
@@ -9784,7 +9476,7 @@ def fast_copy(infp, outfp, bufsize=1 << 20):
             outfp.write(data)
 
 
-def copy_file_to_mmap_dest(src_path, outfp, chunk_size=8 << 20):
+def copy_file_to_mmap_dest(src_path, outfp, chunk_size=__spoolfile_size__):
     """
     Copy a disk file into an mmap-backed destination (FileLikeAdapter).
     Falls back to buffered copy if the source cannot be mmapped.
@@ -10010,9 +9702,6 @@ def CompressOpenFile(outfile, compressionenable=True, compressionlevel=None,
         elif (fextname == ".lz4" and "lz4" in compressionsupport):
             outfp = FileLikeAdapter(lz4.frame.open(outfile, mode, compression_level=compressionlevel), mode="wb")
 
-        elif (fextname == ".lzo" and "lzop" in compressionsupport):
-            outfp = FileLikeAdapter(LzopFile(outfile, mode=mode, level=compressionlevel), mode="wb")
-
         elif (fextname == ".lzma" and "lzma" in compressionsupport):
             try:
                 outfp = FileLikeAdapter(
@@ -10134,7 +9823,7 @@ if(not py7zr_support):
 
 if(py7zr_support):
     def PackArchiveFileFromSevenZipFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["crc32", "crc32", "crc32", "crc32"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-        return AppendFilesWithContentFromSevenZipToOutFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, verbose, returnfp)
+        return AppendFilesWithContentFromSevenZipFileToOutFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, verbose, returnfp)
 
 
 def PackArchiveFileFromInFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["crc32", "crc32", "crc32"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
@@ -10242,14 +9931,6 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
         checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
-        if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-            return ZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-            return RarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-            return SevenZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
         elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
@@ -10611,9 +10292,10 @@ def StackedArchiveFileValidate(infile, fmttype="auto", filestart=0, formatspecs=
     while True:
         if outstartfile >= outfsize:   # stop when function signals False
             break
-        is_valid_file = ArchiveFileValidate(infile, fmttype, filestart, formatspecs, seektoend, verbose, True)
+        is_valid_file = ArchiveFileValidate(infile, fmttype, outstartfile, formatspecs, seektoend, verbose, True)
         if is_valid_file is False:   # stop when function signals False
             outretval.append(is_valid_file)
+            break
         else:
             outretval.append(True)
         infile = is_valid_file
@@ -11619,35 +11301,6 @@ def MultipleArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=
     return outretval
 
 
-def StackedArchiveFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
-    outretval = []
-    outstartfile = filestart
-    outfsize = float('inf')
-    while True:
-        if outstartfile >= outfsize:   # stop when function signals False
-            break
-        is_valid_file = ArchiveFileValidate(infile, fmttype, filestart, formatspecs, seektoend, verbose, True)
-        if is_valid_file is False:   # stop when function signals False
-            outretval.append(is_valid_file)
-        else:
-            outretval.append(True)
-        infile = is_valid_file
-        outstartfile = infile.tell()
-        try:
-            infile.seek(0, 2)
-        except OSError:
-            SeekToEndOfFile(infile)
-        except ValueError:
-            SeekToEndOfFile(infile)
-        outfsize = infile.tell()
-        infile.seek(outstartfile, 0)
-    if(returnfp):
-        return infile
-    else:
-        infile.close()
-        return outretval
-
-
 def StackedArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
     outretval = []
     outstartfile = filestart
@@ -11858,11 +11511,11 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
         if(zipinfo.create_system == 0 or zipinfo.create_system == 10):
             fwinattributes = int(zipinfo.external_attr)
             if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
-                fmode = int(stat.S_IFDIR + 511)
-                fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
-                ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
+                fmode = int(stat.S_IFDIR | 0x1ff)
+                fchmode = int(stat.S_IMODE(int(stat.S_IFDIR | 0x1ff)))
+                ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR | 0x1ff)))
             else:
-                fmode = int(stat.S_IFREG + 438)
+                fmode = int(stat.S_IFREG | 0x1b6)
                 fchmode = int(stat.S_IMODE(fmode))
                 ftypemod = int(stat.S_IFMT(fmode))
         elif(zipinfo.create_system == 3):
@@ -11878,11 +11531,11 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
         else:
             fwinattributes = int(0)
             if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
-                fmode = int(stat.S_IFDIR + 511)
-                fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
-                ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
+                fmode = int(stat.S_IFDIR | 0x1ff)
+                fchmode = int(stat.S_IMODE(int(stat.S_IFDIR | 0x1ff)))
+                ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR | 0x1ff)))
             else:
-                fmode = int(stat.S_IFREG + 438)
+                fmode = int(stat.S_IFREG | 0x1b6)
                 fchmode = int(stat.S_IMODE(fmode))
                 ftypemod = int(stat.S_IFMT(fmode))
         returnval.update({lcfi: member.filename})
@@ -11993,11 +11646,11 @@ if(rarfile_support):
             if(is_unix and member.external_attr != 0):
                 fpremode = int(member.external_attr)
             elif(member.is_file()):
-                fpremode = int(stat.S_IFREG + 438)
+                fpremode = int(stat.S_IFREG | 0x1b6)
             elif(member.is_symlink()):
-                fpremode = int(stat.S_IFLNK + 438)
+                fpremode = int(stat.S_IFLNK | 0x1b6)
             elif(member.is_dir()):
-                fpremode = int(stat.S_IFDIR + 511)
+                fpremode = int(stat.S_IFDIR | 0x1ff)
             if(is_windows and member.external_attr != 0):
                 fwinattributes = int(member.external_attr)
             else:
@@ -12007,17 +11660,17 @@ if(rarfile_support):
                 fchmode = int(stat.S_IMODE(member.external_attr))
                 ftypemod = int(stat.S_IFMT(member.external_attr))
             elif(member.is_file()):
-                fmode = int(stat.S_IFREG + 438)
-                fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)))
-                ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)))
+                fmode = int(stat.S_IFREG | 0x1b6)
+                fchmode = int(stat.S_IMODE(int(stat.S_IFREG | 0x1b6)))
+                ftypemod = int(stat.S_IFMT(int(stat.S_IFREG | 0x1b6)))
             elif(member.is_symlink()):
-                fmode = int(stat.S_IFLNK + 438)
-                fchmode = int(stat.S_IMODE(int(stat.S_IFLNK + 438)))
-                ftypemod = int(stat.S_IFMT(int(stat.S_IFLNK + 438)))
+                fmode = int(stat.S_IFLNK | 0x1b6)
+                fchmode = int(stat.S_IMODE(int(stat.S_IFLNK | 0x1b6)))
+                ftypemod = int(stat.S_IFMT(int(stat.S_IFLNK | 0x1b6)))
             elif(member.is_dir()):
-                fmode = int(stat.S_IFDIR + 511)
-                fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
-                ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
+                fmode = int(stat.S_IFDIR | 0x1ff)
+                fchmode = int(stat.S_IMODE(int(stat.S_IFDIR | 0x1ff)))
+                ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR | 0x1ff)))
             returnval.update({lcfi: member.filename})
             if(not verbose):
                 VerbosePrintOut(member.filename)
@@ -12113,18 +11766,18 @@ if(py7zr_support):
             else:
                 fname = "./"+member.filename
             if(not member.is_directory):
-                fpremode = int(stat.S_IFREG + 438)
+                fpremode = int(stat.S_IFREG | 0x1b6)
             elif(member.is_directory):
-                fpremode = int(stat.S_IFDIR + 511)
+                fpremode = int(stat.S_IFDIR | 0x1ff)
             fwinattributes = int(0)
             if(member.is_directory):
-                fmode = int(stat.S_IFDIR + 511)
-                fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
-                ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
+                fmode = int(stat.S_IFDIR | 0x1ff)
+                fchmode = int(stat.S_IMODE(int(stat.S_IFDIR | 0x1ff)))
+                ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR | 0x1ff)))
             else:
-                fmode = int(stat.S_IFLNK + 438)
-                fchmode = int(stat.S_IMODE(int(stat.S_IFLNK + 438)))
-                ftypemod = int(stat.S_IFMT(int(stat.S_IFLNK + 438)))
+                fmode = int(stat.S_IFLNK | 0x1b6)
+                fchmode = int(stat.S_IMODE(int(stat.S_IFLNK | 0x1b6)))
+                ftypemod = int(stat.S_IFMT(int(stat.S_IFLNK | 0x1b6)))
             returnval.update({lcfi: member.filename})
             if(not verbose):
                 VerbosePrintOut(member.filename)