PyCatFile 0.26.0__py3-none-any.whl → 0.27.2__py3-none-any.whl

pycatfile.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: pycatfile.py - Last Update: 11/12/2025 Ver. 0.26.0 RC 1 - Author: cooldude2k $
+    $FileInfo: pycatfile.py - Last Update: 11/15/2025 Ver. 0.27.2 RC 1 - Author: cooldude2k $
 '''
 
 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
@@ -24,7 +24,6 @@ import re
 import sys
 import time
 import stat
-import zlib
 import mmap
 import hmac
 import base64
@@ -38,8 +37,8 @@ import zipfile
 import binascii
 import datetime
 import platform
+import collections
 from io import StringIO, BytesIO
-from collections import namedtuple
 import posixpath  # POSIX-safe joins/normpaths
 try:
     from backports import tempfile
@@ -48,14 +47,16 @@ except ImportError:
 
 try:
     from http.server import BaseHTTPRequestHandler, HTTPServer
-    from socketserver import TCPServer
     from urllib.parse import urlparse, parse_qs
-    import base64
 except ImportError:
     from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
-    from SocketServer import TCPServer
     from urlparse import urlparse, parse_qs
-    import base64
+
+try:
+    # Python 3.8+ only
+    from multiprocessing import shared_memory
+except ImportError:
+    shared_memory = None
 
 # FTP Support
 ftpssl = True
@@ -146,6 +147,15 @@ try:
 except Exception:
     PATH_TYPES = (basestring,)
 
+def running_interactively():
+    main = sys.modules.get("__main__")
+    no_main_file = not hasattr(main, "__file__")
+    interactive_flag = bool(getattr(sys.flags, "interactive", 0))
+    return no_main_file or interactive_flag
+
+if running_interactively():
+    logging.basicConfig(format="%(message)s", stream=PY_STDOUT_TEXT, level=logging.DEBUG)
+
 def _ensure_text(s, encoding="utf-8", errors="replace", allow_none=False):
     """
     Normalize any input to text_type (unicode on Py2, str on Py3).
@@ -166,7 +176,6 @@ def _ensure_text(s, encoding="utf-8", errors="replace", allow_none=False):
 
     # Handle pathlib.Path & other path-like objects
     try:
-        import os
         if hasattr(os, "fspath"):
             fs = os.fspath(s)
             if isinstance(fs, text_type):
@@ -207,7 +216,6 @@ except ImportError:
 
 # Windows-specific setup
 if os.name == "nt":
-    import io
     def _wrap(stream):
         buf = getattr(stream, "buffer", None)
         is_tty = getattr(stream, "isatty", lambda: False)()
@@ -444,7 +452,13 @@ if('PYCATFILE_CONFIG_FILE' in os.environ and os.path.exists(os.environ['PYCATFIL
 else:
     prescriptpath = get_importing_script_path()
     if(prescriptpath is not None):
-        scriptconf = os.path.join(os.path.dirname(prescriptpath), __use_ini_name__)
+        if(__use_ini_file__ and not __use_json_file__):
+            scriptconf = os.path.join(os.path.dirname(prescriptpath), __use_ini_name__)
+        elif(__use_json_file__ and not __use_ini_file__):
+            scriptconf = os.path.join(os.path.dirname(prescriptpath), __use_json_name__)
+        else:
+            scriptconf = ""
+            prescriptpath = None
     else:
         scriptconf = ""
 if os.path.exists(scriptconf):
@@ -647,12 +661,12 @@ __project__ = __program_name__
 __program_alt_name__ = __program_name__
 __project_url__ = "https://github.com/GameMaker2k/PyCatFile"
 __project_release_url__ = __project_url__+"/releases/latest"
-__version_info__ = (0, 26, 0, "RC 1", 1)
-__version_date_info__ = (2025, 11, 12, "RC 1", 1)
+__version_info__ = (0, 27, 2, "RC 1", 1)
+__version_date_info__ = (2025, 11, 15, "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: 1f4434bfb0e0cb5e732daced1add124d7b880a31 $"
+__revision_id__ = "$Id: 44c63222877d771eec434744489e580eea061ad6 $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -804,9 +818,9 @@ except Exception:
 geturls_ua_pyfile_python = "Mozilla/5.0 (compatible; {proname}/{prover}; +{prourl})".format(
     proname=__project__, prover=__version__, prourl=__project_url__)
 if(platform.python_implementation() != ""):
-    py_implementation = platform.python_implementation()
+    py_implementation = platform.python_implementation()+str(platform.python_version_tuple()[0])
 if(platform.python_implementation() == ""):
-    py_implementation = "CPython"
+    py_implementation = "CPython"+str(platform.python_version_tuple()[0])
 geturls_ua_pyfile_python_alt = "Mozilla/5.0 ({osver}; {archtype}; +{prourl}) {pyimp}/{pyver} (KHTML, like Gecko) {proname}/{prover}".format(osver=platform.system(
 )+" "+platform.release(), archtype=platform.machine(), prourl=__project_url__, pyimp=py_implementation, pyver=platform.python_version(), proname=__project__, prover=__version__)
 geturls_ua_googlebot_google = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
@@ -822,13 +836,19 @@ geturls_headers_googlebot_google_old = {'Referer': "http://google.com/", 'User-A
 
 compressionsupport = []
 try:
-    import gzip
+    try:
+        import compression.gzip as gzip
+    except ImportError:
+        import gzip
     compressionsupport.append("gz")
     compressionsupport.append("gzip")
 except ImportError:
     pass
 try:
-    import bz2
+    try:
+        import compression.bz2 as bz2
+    except ImportError:
+        import bz2
     compressionsupport.append("bz2")
     compressionsupport.append("bzip2")
 except ImportError:
@@ -849,35 +869,39 @@ except ImportError:
     pass
 '''
 try:
-    import zstandard
+    try:
+        import compression.zstd as zstd
+    except ImportError:
+        import pyzstd.zstdfile as zstd
     compressionsupport.append("zst")
     compressionsupport.append("zstd")
     compressionsupport.append("zstandard")
 except ImportError:
+    pass
+try:
     try:
-        import pyzstd.zstdfile
-        compressionsupport.append("zst")
-        compressionsupport.append("zstd")
-        compressionsupport.append("zstandard")
+        import compression.lzma as lzma
     except ImportError:
-        pass
-try:
-    import lzma
+        try:
+            import lzma
+        except ImportError:
+            from backports import lzma
     compressionsupport.append("lzma")
     compressionsupport.append("xz")
 except ImportError:
+    pass
+try:
     try:
-        from backports import lzma
-        compressionsupport.append("lzma")
-        compressionsupport.append("xz")
+        import compression.zlib as zlib
     except ImportError:
-        pass
-compressionsupport.append("zlib")
-compressionsupport.append("zl")
-compressionsupport.append("zz")
-compressionsupport.append("Z")
-compressionsupport.append("z")
-
+        import zlib
+    compressionsupport.append("zlib")
+    compressionsupport.append("zl")
+    compressionsupport.append("zz")
+    compressionsupport.append("Z")
+    compressionsupport.append("z")
+except ImportError:
+    pass
 compressionlist = ['auto']
 compressionlistalt = []
 outextlist = []
@@ -1051,6 +1075,14 @@ def to_ns(timestamp):
     # Multiply by 1e9 to get nanoseconds, then cast to int
     return int(seconds * 1000000000)
 
+def format_ns_utc(ts_ns, fmt='%Y-%m-%d %H:%M:%S'):
+    ts_ns = int(ts_ns)
+    sec, ns = divmod(ts_ns, 10**9)
+    dt = datetime.datetime.utcfromtimestamp(sec).replace(microsecond=ns // 1000)
+    base = dt.strftime(fmt)
+    ns_str = "%09d" % ns
+    return base + "." + ns_str
+
 def _split_posix(name):
     """
     Return a list of path parts without collapsing '..'.
@@ -2087,7 +2119,7 @@ def MkTempFile(data=None,
                spool_max=__spoolfile_size__,
                spool_dir=__use_spooldir__,
                reset_to_start=True,
-               memfd_name=None,
+               memfd_name=__program_name__,
                memfd_allow_sealing=False,
                memfd_flags_extra=0,
                on_create=None):
@@ -2579,6 +2611,384 @@ def _is_valid_zlib_header(cmf, flg):
         return False
     return True
 
+class SharedMemoryFile(object):
+    """
+    File-like wrapper around multiprocessing.shared_memory.SharedMemory.
+
+    Binary-only API, intended to behave similarly to a regular file opened in
+    'rb', 'wb', or 'r+b' modes (but backed by a fixed-size shared memory block).
+
+    Notes:
+      - Requires Python 3.8+ at runtime to actually use SharedMemory.
+      - On Python 2, importing is fine but constructing will raise RuntimeError.
+      - There is no automatic resizing; buffer size is fixed by SharedMemory.
+      - No real fileno(); this does not represent an OS-level file descriptor.
+      - For text mode, wrap this with io.TextIOWrapper on Python 3:
+            f = SharedMemoryFile(...)
+            tf = io.TextIOWrapper(f, encoding="utf-8")
+    """
+
+    def __init__(self, shm=None, name=None, create=False, size=0,
+                 mode='r+b', offset=0, unlink_on_close=False):
+        """
+        Parameters:
+          shm   : existing SharedMemory object (preferred).
+          name  : name of shared memory block (for attach or create).
+          create: if True, create new SharedMemory; else attach existing.
+          size  : size in bytes (required when create=True).
+          mode  : like 'rb', 'wb', 'r+b', 'ab' (binary only; 't' not supported).
+          offset: starting offset within the shared memory buffer.
+          unlink_on_close: if True, call shm.unlink() when close() is called.
+
+        Usage examples:
+
+            # Create new block and file-like wrapper
+            f = SharedMemoryFile(name=None, create=True, size=4096, mode='r+b')
+
+            # Attach to existing shared memory by name
+            f = SharedMemoryFile(name="xyz", create=False, mode='r+b')
+
+            # Wrap an existing SharedMemory object
+            shm = shared_memory.SharedMemory(create=True, size=1024)
+            f = SharedMemoryFile(shm=shm, mode='r+b')
+        """
+        if shared_memory is None:
+            # No SharedMemory available on this interpreter
+            raise RuntimeError("multiprocessing.shared_memory.SharedMemory "
+                               "is not available on this Python version")
+
+        if 't' in mode:
+            raise ValueError("SharedMemoryFile is binary-only; "
+                             "wrap it with io.TextIOWrapper for text")
+
+        self.mode = mode
+        self._closed = False
+        self._unlinked = False
+        self._unlink_on_close = bool(unlink_on_close)
+
+        if shm is not None:
+            self._shm = shm
+        else:
+            # name may be None when create=True
+            self._shm = shared_memory.SharedMemory(name=name, create=create, size=size)
+
+        self._buf = self._shm.buf
+        self._base_offset = int(offset)
+        if self._base_offset < 0 or self._base_offset > len(self._buf):
+            raise ValueError("offset out of range")
+
+        # We treat the accessible region as [base_offset, len(buf))
+        self._size = len(self._buf) - self._base_offset
+        self._pos = 0  # logical file position within that region
+
+    # ---------- basic properties ----------
+
+    @property
+    def name(self):
+        # SharedMemory name (may be None for anonymous)
+        return getattr(self._shm, "name", None)
+
+    @property
+    def closed(self):
+        return self._closed
+
+    def readable(self):
+        return ('r' in self.mode) or ('+' in self.mode)
+
+    def writable(self):
+        return any(ch in self.mode for ch in ('w', 'a', '+'))
+
+    def seekable(self):
+        return True
+
+    # ---------- core helpers ----------
+
+    def _check_closed(self):
+        if self._closed:
+            raise ValueError("I/O operation on closed SharedMemoryFile")
+
+    def _clamp_pos(self, pos):
+        if pos < 0:
+            return 0
+        if pos > self._size:
+            return self._size
+        return pos
+
+    def _region_bounds(self):
+        """Return (start, end) absolute indices into the SharedMemory buffer."""
+        start = self._base_offset + self._pos
+        end = self._base_offset + self._size
+        return start, end
+
+    # ---------- positioning ----------
+
+    def seek(self, offset, whence=0):
+        """
+        Seek to a new file position.
+
+        whence: 0 = from start, 1 = from current, 2 = from end.
+        """
+        self._check_closed()
+        offset = int(offset)
+        whence = int(whence)
+
+        if whence == 0:   # from start
+            new_pos = offset
+        elif whence == 1: # from current
+            new_pos = self._pos + offset
+        elif whence == 2: # from end
+            new_pos = self._size + offset
+        else:
+            raise ValueError("invalid whence (expected 0, 1, or 2)")
+
+        self._pos = self._clamp_pos(new_pos)
+        return self._pos
+
+    def tell(self):
+        return self._pos
+
+    # ---------- reading ----------
+
+    def read(self, size=-1):
+        """
+        Read up to 'size' bytes (or to EOF if size<0 or None).
+        Returns bytes (py3) or str (py2).
+        """
+        self._check_closed()
+        if not self.readable():
+            raise IOError("SharedMemoryFile not opened for reading")
+
+        if size is None or size < 0:
+            size = self._size - self._pos
+        else:
+            size = int(size)
+            if size < 0:
+                size = 0
+
+        if size == 0:
+            return b'' if not PY2 else ''
+
+        start, end_abs = self._region_bounds()
+        available = end_abs - (self._base_offset + self._pos)
+        if available <= 0:
+            return b'' if not PY2 else ''
+
+        size = min(size, available)
+
+        abs_start = self._base_offset + self._pos
+        abs_end = abs_start + size
+
+        chunk = self._buf[abs_start:abs_end]
+        if PY2:
+            data = bytes(chunk)  # bytes() -> str in py2
+        else:
+            data = bytes(chunk)
+
+        self._pos += len(data)
+        return data
+
+    def readline(self, size=-1):
+        """
+        Read a single line (ending with '\\n' or EOF).
+        If size >= 0, at most that many bytes are returned.
+        """
+        self._check_closed()
+        if not self.readable():
+            raise IOError("SharedMemoryFile not opened for reading")
+
+        # Determine maximum bytes we can scan
+        start, end_abs = self._region_bounds()
+        remaining = end_abs - (self._base_offset + self._pos)
+        if remaining <= 0:
+            return b'' if not PY2 else ''
+
+        if size is not None and size >= 0:
+            size = int(size)
+            max_len = min(size, remaining)
+        else:
+            max_len = remaining
+
+        abs_start = self._base_offset + self._pos
+        abs_max = abs_start + max_len
+
+        # Work on a local bytes slice for easy .find()
+        if PY2:
+            buf_bytes = bytes(self._buf[abs_start:abs_max])
+        else:
+            buf_bytes = bytes(self._buf[abs_start:abs_max])
+
+        idx = buf_bytes.find(b'\n')
+        if idx == -1:
+            # No newline; read entire chunk
+            line_bytes = buf_bytes
+        else:
+            line_bytes = buf_bytes[:idx + 1]
+
+        self._pos += len(line_bytes)
+
+        if PY2:
+            return line_bytes  # already str
+        return line_bytes
+
+    def readinto(self, b):
+        """
+        Read bytes into a pre-allocated writable buffer (bytearray/memoryview).
+        Returns number of bytes read.
+        """
+        self._check_closed()
+        if not self.readable():
+            raise IOError("SharedMemoryFile not opened for reading")
+
+        # Normalize target buffer
+        if isinstance(b, memoryview):
+            mv = b
+        else:
+            mv = memoryview(b)
+
+        size = len(mv)
+        if size <= 0:
+            return 0
+
+        start, end_abs = self._region_bounds()
+        remaining = end_abs - (self._base_offset + self._pos)
+        if remaining <= 0:
+            return 0
+
+        size = min(size, remaining)
+
+        abs_start = self._base_offset + self._pos
+        abs_end = abs_start + size
+
+        mv[:size] = self._buf[abs_start:abs_end]
+        self._pos += size
+        return size
+
+    # ---------- writing ----------
+
+    def write(self, data):
+        """
+        Write bytes-like object to the shared memory region.
+
+        Returns number of bytes written. Will raise if not opened writable
+        or if writing would overflow the fixed-size region.
+        """
+        self._check_closed()
+        if not self.writable():
+            raise IOError("SharedMemoryFile not opened for writing")
+
+        if isinstance(data, memoryview):
+            data = bytes(data)
+        elif isinstance(data, bytearray):
+            data = bytes(data)
+
+        if not isinstance(data, binary_types):
+            raise TypeError("write() expects a bytes-like object")
+
+        data_len = len(data)
+        if data_len == 0:
+            return 0
+
+        # Handle "append" semantics roughly: start from end on first write
+        if 'a' in self.mode and self._pos == 0:
+            # Move to logical end of region
+            self._pos = self._size
+
+        start, end_abs = self._region_bounds()
+        remaining = end_abs - (self._base_offset + self._pos)
+        if data_len > remaining:
+            raise IOError("write would overflow SharedMemory region (need %d, have %d)"
+                          % (data_len, remaining))
+
+        abs_start = self._base_offset + self._pos
+        abs_end = abs_start + data_len
+
+        self._buf[abs_start:abs_end] = data
+        self._pos += data_len
+        return data_len
+
+    def flush(self):
+        """
+        No-op for shared memory; provided for file-like compatibility.
+        """
+        self._check_closed()
+        # nothing to flush
+
+    # ---------- unlink / close / context manager ----------
+
+    def unlink(self):
+        """
+        Unlink (destroy) the underlying shared memory block.
+
+        After unlink(), new processes cannot attach via name.
+        Existing attachments (including this one) can continue to use
+        the memory until they close() it.
+
+        This is idempotent: calling it more than once is safe.
+        """
+        if self._unlinked:
+            return
+
+        try:
+            self._shm.unlink()
+        except AttributeError:
+            # Should not happen on normal Python 3.8+,
+            # but keep a clear error if it does.
+            raise RuntimeError("Underlying SharedMemory object "
+                               "does not support unlink()")
+
+        self._unlinked = True
+
+    def close(self):
+        if self._closed:
+            return
+        self._closed = True
+
+        # Optionally unlink on close if requested
+        if self._unlink_on_close and not self._unlinked:
+            try:
+                self.unlink()
+            except Exception:
+                # best-effort; close anyway
+                pass
+
+        try:
+            self._shm.close()
+        except Exception:
+            pass
+
+    def __enter__(self):
+        self._check_closed()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    # ---------- iteration ----------
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        line = self.readline()
+        if (not line) or len(line) == 0:
+            raise StopIteration
+        return line
+
+    if PY2:
+        next = __next__
+
+    # ---------- misc helpers ----------
+
+    def fileno(self):
+        """
+        There is no real OS-level file descriptor; raise OSError for APIs
+        that require a fileno().
+        """
+        raise OSError("SharedMemoryFile does not have a real fileno()")
+
+    def isatty(self):
+        return False
+
 # ---------- Main class ----------
 class ZlibFile(object):
     """
@@ -4470,7 +4880,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
         extrastart = extrastart + 1
     fvendorfieldslist = []
     fvendorfields = 0;
-    if(len(HeaderOut)>extraend):
+    if((len(HeaderOut) - 4)>extraend):
         extrastart = extraend
         extraend = len(HeaderOut) - 4
         while(extrastart < extraend):
@@ -4690,6 +5100,15 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
     while(extrastart < extraend):
         fextrafieldslist.append(HeaderOut[extrastart])
         extrastart = extrastart + 1
+    fvendorfieldslist = []
+    fvendorfields = 0;
+    if((len(HeaderOut) - 4)>extraend):
+        extrastart = extraend
+        extraend = len(HeaderOut) - 4
+        while(extrastart < extraend):
+            fvendorfieldslist.append(HeaderOut[extrastart])
+            extrastart = extrastart + 1
+            fvendorfields = fvendorfields + 1
     if(fextrafields==1):
         try:
             fextrafieldslist = json.loads(base64.b64decode(fextrafieldslist[0]).decode("UTF-8"))
@@ -4699,6 +5118,7 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
                 fextrafieldslist = json.loads(fextrafieldslist[0])
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 pass
+    fjstart = fp.tell()
     if(fjsontype=="json"):
         fjsoncontent = {}
         fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
@@ -4765,6 +5185,7 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
                 except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                     pass
     fp.seek(len(delimiter), 1)
+    fjend = fp.tell() - 1
     jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs, saltkey)
     if(not CheckChecksums(fjsonchecksum, jsonfcs) and not skipchecksum):
         VerbosePrintOut("File JSON Data Checksum Error with file " +
@@ -4797,6 +5218,7 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
         pyhascontents = False
     fcontents.seek(0, 0)
     newfccs = GetFileChecksum(fcontents, HeaderOut[-3].lower(), False, formatspecs, saltkey)
+    fcontents.seek(0, 0)
     if(not CheckChecksums(fccs, newfccs) and not skipchecksum and not listonly):
         VerbosePrintOut("File Content Checksum Error with file " +
                         fname + " at offset " + str(fcontentstart))
@@ -4836,8 +5258,8 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
     fcontents.seek(0, 0)
     if(not contentasfile):
         fcontents = fcontents.read()
-    outlist = [ftype, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression, fcsize, fuid, funame, fgid, fgname, fid,
-               finode, flinkcount, fdev, frdev, fseeknextfile, fjsoncontent, fextrafieldslist, HeaderOut[-4], HeaderOut[-3], fcontents]
+    outlist = {'fheaders': [ftype, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
+               fcsize, fuid, funame, fgid, fgname, fid, finode, flinkcount, fdev, frdev, fseeknextfile], 'fextradata': fextrafieldslist, 'fjsoncontent': fjsoncontent, 'fcontents': fcontents, 'fjsonchecksumtype': fjsonchecksumtype, 'fheaderchecksumtype': HeaderOut[-4].lower(), 'fcontentchecksumtype': HeaderOut[-3].lower()}
     return outlist
 
 
@@ -4854,6 +5276,7 @@ def ReadFileDataWithContent(fp, filestart=0, listonly=False, uncompress=True, sk
     CatSizeEnd = CatSize
     fp.seek(curloc, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
+    headeroffset = fp.tell()
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
     formdel = fp.read(formdelszie).decode("UTF-8")
@@ -4873,7 +5296,7 @@ def ReadFileDataWithContent(fp, filestart=0, listonly=False, uncompress=True, sk
     newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs, saltkey)
     if(not headercheck and not skipchecksum):
         VerbosePrintOut(
-            "File Header Checksum Error with file at offset " + str(0))
+            "File Header Checksum Error with file at offset " + str(headeroffset))
         VerbosePrintOut("'" + fprechecksum + "' != " +
                         "'" + newfcs + "'")
         return False
@@ -4925,6 +5348,7 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
     CatSizeEnd = CatSize
     fp.seek(curloc, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
+    headeroffset = fp.tell()
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
     formdel = fp.read(formdelszie).decode("UTF-8")
@@ -4957,7 +5381,7 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
                 pass
     fvendorfieldslist = []
     fvendorfields = 0;
-    if(len(inheader)>extraend):
+    if((len(inheader) - 2)>extraend):
         extrastart = extraend
         extraend = len(inheader) - 2
         while(extrastart < extraend):
@@ -4967,8 +5391,8 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
     formversion = re.findall("([\\d]+)", formstring)
     fheadsize = int(inheader[0], 16)
     fnumfields = int(inheader[1], 16)
-    fheadctime = int(inheader[1], 16)
-    fheadmtime = int(inheader[1], 16)
+    fheadctime = int(inheader[2], 16)
+    fheadmtime = int(inheader[3], 16)
     fhencoding = inheader[4]
     fostype = inheader[5]
     fpythontype = inheader[6]
@@ -5077,7 +5501,7 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
     newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs, saltkey)
     if(not headercheck and not skipchecksum):
         VerbosePrintOut(
-            "File Header Checksum Error with file at offset " + str(0))
+            "File Header Checksum Error with file at offset " + str(headeroffset))
         VerbosePrintOut("'" + fprechecksum + "' != " +
                         "'" + newfcs + "'")
         return False
@@ -5187,6 +5611,7 @@ def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listo
     CatSizeEnd = CatSize
     fp.seek(curloc, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
+    headeroffset = fp.tell()
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
     formdel = fp.read(formdelszie).decode("UTF-8")
@@ -5214,22 +5639,101 @@ def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listo
             fnumextrafields = len(fextrafieldslist)
         except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
             try:
-                fextrafieldslist = json.loads(fextrafieldslist[0])
+                fextrafieldslist = json.loads(fextrafieldslist[0])
+            except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
+                pass
+    fvendorfieldslist = []
+    fvendorfields = 0;
+    if((len(inheader) - 2)>extraend):
+        extrastart = extraend
+        extraend = len(inheader) - 2
+        while(extrastart < extraend):
+            fvendorfieldslist.append(HeaderOut[extrastart])
+            extrastart = extrastart + 1
+            fvendorfields = fvendorfields + 1
+    formversion = re.findall("([\\d]+)", formstring)
+    fheadsize = int(inheader[0], 16)
+    fnumfields = int(inheader[1], 16)
+    fheadctime = int(inheader[2], 16)
+    fheadmtime = int(inheader[3], 16)
+    fhencoding = inheader[4]
+    fostype = inheader[5]
+    fpythontype = inheader[6]
+    fprojectname = inheader[7]
+    fnumfiles = int(inheader[8], 16)
+    fseeknextfile = inheader[9]
+    fjsontype = inheader[10]
+    fjsonlen = int(inheader[11], 16)
+    fjsonsize = int(inheader[12], 16)
+    fjsonchecksumtype = inheader[13]
+    fjsonchecksum = inheader[14]
+    fjsoncontent = {}
+    fjstart = fp.tell()
+    if(fjsontype=="json"):
+        fjsoncontent = {}
+        fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
+        if(fjsonsize > 0):
+            try:
+                fjsonrawcontent = base64.b64decode(fprejsoncontent.encode("UTF-8")).decode("UTF-8")
+                fjsoncontent = json.loads(base64.b64decode(fprejsoncontent.encode("UTF-8")).decode("UTF-8"))
+            except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
+                try:
+                    fjsonrawcontent = fprejsoncontent
+                    fjsoncontent = json.loads(fprejsoncontent)
+                except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
+                    fprejsoncontent = ""
+                    fjsonrawcontent = fprejsoncontent 
+                    fjsoncontent = {}
+        else:
+            fprejsoncontent = ""
+            fjsonrawcontent = fprejsoncontent 
+            fjsoncontent = {}
+    elif(testyaml and fjsontype == "yaml"):
+        fjsoncontent = {}
+        fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
+        if (fjsonsize > 0):
+            try:
+                # try base64 → utf-8 → YAML
+                fjsonrawcontent = base64.b64decode(fprejsoncontent.encode("UTF-8")).decode("UTF-8")
+                fjsoncontent = yaml.safe_load(fjsonrawcontent) or {}
+            except (binascii.Error, UnicodeDecodeError, yaml.YAMLError):
+                try:
+                    # fall back to treating the bytes as plain text YAML
+                    fjsonrawcontent = fprejsoncontent
+                    fjsoncontent = yaml.safe_load(fjsonrawcontent) or {}
+                except (UnicodeDecodeError, yaml.YAMLError):
+                    # final fallback: empty
+                    fprejsoncontent = ""
+                    fjsonrawcontent = fprejsoncontent
+                    fjsoncontent = {}
+        else:
+            fprejsoncontent = ""
+            fjsonrawcontent = fprejsoncontent
+            fjsoncontent = {}
+    elif(not testyaml and fjsontype == "yaml"):
+        fjsoncontent = {}
+        fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
+        fprejsoncontent = ""
+        fjsonrawcontent = fprejsoncontent
+    elif(fjsontype=="list"):
+        fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
+        flisttmp = MkTempFile()
+        flisttmp.write(fprejsoncontent.encode())
+        flisttmp.seek(0)
+        fjsoncontent = ReadFileHeaderData(flisttmp, fjsonlen, delimiter)
+        flisttmp.close()
+        fjsonrawcontent = fjsoncontent
+        if(fjsonlen==1):
+            try:
+                fjsonrawcontent = base64.b64decode(fjsoncontent[0]).decode("UTF-8")
+                fjsoncontent = json.loads(base64.b64decode(fjsoncontent[0]).decode("UTF-8"))
+                fjsonlen = len(fjsoncontent)
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
-                pass
-    formversion = re.findall("([\\d]+)", formstring)
-    fheadsize = int(inheader[0], 16)
-    fnumfields = int(inheader[1], 16)
-    fnumfiles = int(inheader[8], 16)
-    fseeknextfile = inheaderdata[9]
-    fjsontype = int(inheader[10], 16)
-    fjsonlen = int(inheader[11], 16)
-    fjsonsize = int(inheader[12], 16)
-    fjsonchecksumtype = inheader[13]
-    fjsonchecksum = inheader[14]
-    fjsoncontent = {}
-    fjstart = fp.tell()
-    fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
+                try:
+                    fjsonrawcontent = fjsoncontent[0]
+                    fjsoncontent = json.loads(fjsoncontent[0])
+                except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
+                    pass
     fjend = fp.tell()
     if(re.findall("^\\+([0-9]+)", fseeknextfile)):
         fseeknextasnum = int(fseeknextfile.replace("+", ""))
@@ -5260,7 +5764,7 @@ def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listo
     newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs, saltkey)
     if(not headercheck and not skipchecksum):
         VerbosePrintOut(
-            "File Header Checksum Error with file at offset " + str(0))
+            "File Header Checksum Error with file at offset " + str(headeroffset))
         VerbosePrintOut("'" + fprechecksum + "' != " +
                         "'" + newfcs + "'")
         return False
@@ -5764,7 +6268,7 @@ def AppendFileHeader(fp, numfiles, fencoding, extradata=[], jsondata={}, checksu
     else:
         fctime = format(int(to_ns(time.time())), 'x').lower()
     # Serialize the first group
-    fnumfilesa = AppendNullBytes([tmpoutlenhex, fctime, fctime, fencoding, platform.system(), py_implementation, __program_name__, fnumfiles_hex, "+"+str(len(formatspecs['format_delimiter']))], delimiter)
+    fnumfilesa = AppendNullBytes([tmpoutlenhex, fctime, fctime, fencoding, platform.system(), py_implementation, __program_name__+str(__version_info__[0]), fnumfiles_hex, "+"+str(len(formatspecs['format_delimiter']))], delimiter)
     # Append tmpoutlist
     fnumfilesa += AppendNullBytes(tmpoutlist, delimiter)
     # Append extradata items if any
@@ -5990,22 +6494,33 @@ def AppendFileHeaderWithContent(fp, filevalues=[], extradata=[], jsondata={}, fi
         pass
     return fp
 
-def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
-    if(not hasattr(fp, "write")):
-        return False
+def AppendFilesWithContentToList(infiles, dirlistfromtxt=False, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
     advancedlist = __use_advanced_list__
     altinode = __use_alt_inode__
     infilelist = []
-    if(infiles == "-"):
+    if(not dirlistfromtxt and not isinstance(infiles, (list, tuple, )) and infiles == "-"):
         for line in PY_STDIN_TEXT:
             infilelist.append(line.strip())
         infilelist = list(filter(None, infilelist))
-    elif(infiles != "-" and dirlistfromtxt and os.path.exists(infiles) and (os.path.isfile(infiles) or infiles == os.devnull)):
-        if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
-            return False
-        with UncompressFile(infiles, formatspecs, "r") as finfile:
-            for line in finfile:
-                infilelist.append(line.strip())
+    if(not dirlistfromtxt and isinstance(infiles, (list, tuple, )) and len(infiles)==1 and infiles[0] == "-"):
+        for line in PY_STDIN_TEXT:
+            infilelist.append(line.strip())
+        infilelist = list(filter(None, infilelist))
+    elif(dirlistfromtxt):
+        if(not isinstance(infiles, (list, tuple, ))):
+            infiles = [infiles]
+        if(isinstance(infiles, (list, tuple, ))):
+            for fileloc in infiles:
+                if(fileloc == "-"):
+                    for line in PY_STDIN_TEXT:
+                        infilelist.append(line.strip())
+                else:
+                    if(not os.path.exists(fileloc) or not os.path.isfile(fileloc)):
+                        return False
+                    else:
+                        with UncompressFile(fileloc, formatspecs, "r") as finfile:
+                            for line in finfile:
+                                infilelist.append(line.strip())
         infilelist = list(filter(None, infilelist))
     else:
         if(isinstance(infiles, (list, tuple, ))):
@@ -6034,16 +6549,8 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
     inodetofile = {}
     filetoinode = {}
     inodetoforminode = {}
-    numfiles = int(len(GetDirList))
-    fnumfiles = format(numfiles, 'x').lower()
-    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
-    try:
-        fp.flush()
-        if(hasattr(os, "sync")):
-            os.fsync(fp.fileno())
-    except (io.UnsupportedOperation, AttributeError, OSError):
-        pass
     FullSizeFilesAlt = 0
+    tmpoutlist = []
     for curfname in GetDirList:
         fencoding = "UTF-8"
         if(re.findall("^[.|/]", curfname)):
@@ -6218,7 +6725,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
                 typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
                 if(typechecktest is not False):
-                    typechecktest = GetBinaryFileType(fcontents, filestart=0, closefp=True)
+                    typechecktest = GetBinaryFileType(fcontents, filestart=0, closefp=False)
                     fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, 0, False)[0]
                 if(typechecktest is False and not compresswholefile):
@@ -6267,7 +6774,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
                 typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
                 if(typechecktest is not False):
-                    typechecktest = GetBinaryFileType(fcontents, filestart=0, closefp=True)
+                    typechecktest = GetBinaryFileType(fcontents, filestart=0, closefp=False)
                     fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, 0, False)[0]
                 if(typechecktest is False and not compresswholefile):
@@ -6311,10 +6818,29 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
         if(fcompression == "none"):
             fcompression = ""
         fcontents.seek(0, 0)
+        if(not contentasfile):
+            fcontents = fcontents.read()
         ftypehex = format(ftype, 'x').lower()
-        tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
-                      fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))]
-        AppendFileHeaderWithContent(fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs, saltkey)
+        tmpoutlist.append({'fheaders': [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
+                           fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))], 'fextradata': extradata, 'fjsoncontent': jsondata, 'fcontents': fcontents, 'fjsonchecksumtype': checksumtype[2], 'fheaderchecksumtype': checksumtype[0], 'fcontentchecksumtype': checksumtype[1]})
+    return tmpoutlist
+
+def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+    GetDirList = AppendFilesWithContentToList(infiles, dirlistfromtxt, extradata, jsondata, False, compression, compresswholefile, compressionlevel, compressionuselist, followlink, [checksumtype[2], checksumtype[3], checksumtype[3]], formatspecs, saltkey, verbose)
+    if(not hasattr(fp, "write")):
+        return False
+    numfiles = int(len(GetDirList))
+    fnumfiles = format(numfiles, 'x').lower()
+    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
+    try:
+        fp.flush()
+        if(hasattr(os, "sync")):
+            os.fsync(fp.fileno())
+    except (io.UnsupportedOperation, AttributeError, OSError):
+        pass
+    for curfname in GetDirList:
+        tmpoutlist = curfname['fheaders']
+        AppendFileHeaderWithContent(fp, tmpoutlist, curfname['fextradata'], curfname['fjsoncontent'], curfname['fcontents'], [curfname['fheaderchecksumtype'], curfname['fcontentchecksumtype'], curfname['fjsonchecksumtype']], formatspecs, saltkey)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -6323,16 +6849,14 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
             pass
     return fp
 
-def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
-    if(not hasattr(fp, "write")):
-        return False
+def AppendFilesWithContentFromTarFileToList(infile, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
     curinode = 0
     curfid = 0
     inodelist = []
     inodetofile = {}
     filetoinode = {}
     inodetoforminode = {}
-    if(infile == "-"):
+    if(not isinstance(infile, (list, tuple, )) and infile == "-"):
         infile = MkTempFile()
         shutil.copyfileobj(PY_STDIN_BUF, infile, length=__filebuff_size__)
         infile.seek(0, 0)
@@ -6367,10 +6891,8 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
-                if 'zstandard' in sys.modules:
-                    infile = ZstdFile(fileobj=infile, mode="rb")
-                elif 'pyzstd' in sys.modules:
-                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                if 'zstd' in compressionsupport:
+                    infile = zstd.ZstdFile(infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(fileobj=infile, mode="r")
@@ -6379,23 +6901,14 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
-                if 'zstandard' in sys.modules:
-                    infile = ZstdFile(fileobj=infile, mode="rb")
-                elif 'pyzstd' in sys.modules:
-                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                if 'zstd' in compressionsupport:
+                    infile = zstd.ZstdFile(infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(infile, "r")
     except FileNotFoundError:
         return False
-    numfiles = int(len(tarfp.getmembers()))
-    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
-    try:
-        fp.flush()
-        if(hasattr(os, "sync")):
-            os.fsync(fp.fileno())
-    except (io.UnsupportedOperation, AttributeError, OSError):
-        pass
+    tmpoutlist = []
     for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
         fencoding = "UTF-8"
         if(re.findall("^[.|/]", member.name)):
@@ -6408,16 +6921,10 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
         ffullmode = member.mode
         flinkcount = 0
         fblksize = 0
-        if(hasattr(fstatinfo, "st_blksize")):
-            fblksize = format(int(fstatinfo.st_blksize), 'x').lower()
         fblocks = 0
-        if(hasattr(fstatinfo, "st_blocks")):
-            fblocks = format(int(fstatinfo.st_blocks), 'x').lower()
         fflags = 0
-        if(hasattr(fstatinfo, "st_flags")):
-            fflags = format(int(fstatinfo.st_flags), 'x').lower()
         ftype = 0
-        if(member.isreg()):
+        if(member.isreg() or member.isfile()):
             ffullmode = member.mode + stat.S_IFREG
             ftype = 0
         elif(member.islnk()):
@@ -6493,7 +7000,7 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
             typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
             fcontents.seek(0, 0)
             if(typechecktest is not False):
-                typechecktest = GetBinaryFileType(fcontents, filestart=0, closefp=True)
+                typechecktest = GetBinaryFileType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
             fcencoding = GetFileEncoding(fcontents, 0, False)[0]
             if(typechecktest is False and not compresswholefile):
@@ -6537,29 +7044,45 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
         if(fcompression == "none"):
             fcompression = ""
         fcontents.seek(0, 0)
+        if(not contentasfile):
+            fcontents = fcontents.read()
         ftypehex = format(ftype, 'x').lower()
-        tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
-                      fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))]
-        AppendFileHeaderWithContent(fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs, saltkey)
+        tmpoutlist.append({'fheaders': [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
+                           fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))], 'fextradata': extradata, 'fjsoncontent': jsondata, 'fcontents': fcontents, 'fjsonchecksumtype': checksumtype[2], 'fheaderchecksumtype': checksumtype[0], 'fcontentchecksumtype': checksumtype[1]})
+    return tmpoutlist
+
+def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+    if(not hasattr(fp, "write")):
+        return False
+    GetDirList = AppendFilesWithContentFromTarFileToList(infile, extradata, jsondata, False, compression, compresswholefile, compressionlevel, compressionuselist, [checksumtype[2], checksumtype[3], checksumtype[3]], formatspecs, saltkey, verbose)
+    numfiles = int(len(GetDirList))
+    fnumfiles = format(numfiles, 'x').lower()
+    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
+    try:
+        fp.flush()
+        if(hasattr(os, "sync")):
+            os.fsync(fp.fileno())
+    except (io.UnsupportedOperation, AttributeError, OSError):
+        pass
+    for curfname in GetDirList:
+        tmpoutlist = curfname['fheaders']
+        AppendFileHeaderWithContent(fp, tmpoutlist, curfname['fextradata'], curfname['fjsoncontent'], curfname['fcontents'], [curfname['fheaderchecksumtype'], curfname['fcontentchecksumtype'], curfname['fjsonchecksumtype']], formatspecs, saltkey)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
                 os.fsync(fp.fileno())
         except (io.UnsupportedOperation, AttributeError, OSError):
             pass
-        fcontents.close()
     return fp
 
-def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
-    if(not hasattr(fp, "write")):
-        return False
+def AppendFilesWithContentFromZipFileToList(infile, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
     curinode = 0
     curfid = 0
     inodelist = []
     inodetofile = {}
     filetoinode = {}
     inodetoforminode = {}
-    if(infile == "-"):
+    if(not isinstance(infile, (list, tuple, )) and infile == "-"):
         infile = MkTempFile()
         shutil.copyfileobj(PY_STDIN_BUF, infile, length=__filebuff_size__)
         infile.seek(0, 0)
@@ -6585,14 +7108,7 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
     ziptest = zipfp.testzip()
     if(ziptest):
         VerbosePrintOut("Bad file found!")
-    numfiles = int(len(zipfp.infolist()))
-    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
-    try:
-        fp.flush()
-        if(hasattr(os, "sync")):
-            os.fsync(fp.fileno())
-    except (io.UnsupportedOperation, AttributeError, OSError):
-        pass
+    tmpoutlist = []
     for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
         fencoding = "UTF-8"
         if(re.findall("^[.|/]", member.filename)):
@@ -6608,20 +7124,18 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
             fpremode = int(stat.S_IFREG | 0x1b6)
         flinkcount = 0
         fblksize = 0
-        if(hasattr(fstatinfo, "st_blksize")):
-            fblksize = format(int(fstatinfo.st_blksize), 'x').lower()
         fblocks = 0
-        if(hasattr(fstatinfo, "st_blocks")):
-            fblocks = format(int(fstatinfo.st_blocks), 'x').lower()
         fflags = 0
-        if(hasattr(fstatinfo, "st_flags")):
-            fflags = format(int(fstatinfo.st_flags), 'x').lower()
         ftype = 0
         if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
             ftype = 5
+        elif ((hasattr(member, "symlink") and member.symlink())):
+            ftype = 2
         else:
             ftype = 0
         flinkname = ""
+        if(ftype==2):
+            flinkname = zipfp.read(member.filename).decode("UTF-8")
         fcurfid = format(int(curfid), 'x').lower()
         fcurinode = format(int(curfid), 'x').lower()
         curfid = curfid + 1
@@ -6647,6 +7161,10 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
                 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))
+            elif ((hasattr(member, "symlink") and member.symlink()) or member.filename.endswith('/')):
+                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))
             else:
                 fmode = format(int(stat.S_IFREG | 0x1b6), 'x').lower()
                 fchmode = stat.S_IMODE(int(stat.S_IFREG | 0x1b6))
@@ -6655,6 +7173,17 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
             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):
+                fmode = 0
+                prefmode = 0
+            else:
+                file_type = prefmode & 0xF000
+                if(file_type not in (stat.S_IFREG, stat.S_IFDIR, stat.S_IFLNK)):
+                    fmode = 0
+                    prefmode = 0
+                if((mode & 0x1FF) == 0):
+                    fmode = 0
+                    prefmode = 0
             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()
@@ -6755,26 +7284,44 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
         if(fcompression == "none"):
             fcompression = ""
         fcontents.seek(0, 0)
+        if(not contentasfile):
+            fcontents = fcontents.read()
         ftypehex = format(ftype, 'x').lower()
-        tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
-                      fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))]
-        AppendFileHeaderWithContent(fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs, saltkey)
+        tmpoutlist.append({'fheaders': [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
+                           fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))], 'fextradata': extradata, 'fjsoncontent': jsondata, 'fcontents': fcontents, 'fjsonchecksumtype': checksumtype[2], 'fheaderchecksumtype': checksumtype[0], 'fcontentchecksumtype': checksumtype[1]})
+    return tmpoutlist
+
+def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+    if(not hasattr(fp, "write")):
+        return False
+    GetDirList = AppendFilesWithContentFromZipFileToList(infile, extradata, jsondata, False, compression, compresswholefile, compressionlevel, compressionuselist, [checksumtype[2], checksumtype[3], checksumtype[3]], formatspecs, saltkey, verbose)
+    numfiles = int(len(GetDirList))
+    fnumfiles = format(numfiles, 'x').lower()
+    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
+    try:
+        fp.flush()
+        if(hasattr(os, "sync")):
+            os.fsync(fp.fileno())
+    except (io.UnsupportedOperation, AttributeError, OSError):
+        pass
+    for curfname in GetDirList:
+        tmpoutlist = curfname['fheaders']
+        AppendFileHeaderWithContent(fp, tmpoutlist, curfname['fextradata'], curfname['fjsoncontent'], curfname['fcontents'], [curfname['fheaderchecksumtype'], curfname['fcontentchecksumtype'], curfname['fjsonchecksumtype']], formatspecs, saltkey)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
                 os.fsync(fp.fileno())
         except (io.UnsupportedOperation, AttributeError, OSError):
             pass
-        fcontents.close()
     return fp
 
 if(not rarfile_support):
-    def AppendFilesWithContentFromRarFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+    def AppendFilesWithContentFromRarFileToList(infile, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
         return False
-else:       
     def AppendFilesWithContentFromRarFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
-        if(not hasattr(fp, "write")):
-            return False
+        return False
+else:
+    def AppendFilesWithContentFromRarFileToList(infile, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
         curinode = 0
         curfid = 0
         inodelist = []
@@ -6789,20 +7336,7 @@ else:
         rartest = rarfp.testrar()
         if(rartest):
             VerbosePrintOut("Bad file found!")
-        numfiles = int(len(rarfp.infolist()))
-        AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
-        try:
-            fp.flush()
-            if(hasattr(os, "sync")):
-                os.fsync(fp.fileno())
-        except (io.UnsupportedOperation, AttributeError, OSError):
-            pass
-        try:
-            fp.flush()
-            if(hasattr(os, "sync")):
-                os.fsync(fp.fileno())
-        except (io.UnsupportedOperation, AttributeError, OSError):
-            pass
+        tmpoutlist = []
         for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
             is_unix = False
             is_windows = False
@@ -6847,14 +7381,8 @@ else:
             fcsize = format(int(0), 'x').lower()
             flinkcount = 0
             fblksize = 0
-            if(hasattr(fstatinfo, "st_blksize")):
-                fblksize = format(int(fstatinfo.st_blksize), 'x').lower()
             fblocks = 0
-            if(hasattr(fstatinfo, "st_blocks")):
-                fblocks = format(int(fstatinfo.st_blocks), 'x').lower()
             fflags = 0
-            if(hasattr(fstatinfo, "st_flags")):
-                fflags = format(int(fstatinfo.st_flags), 'x').lower()
             ftype = 0
             if(member.is_file()):
                 ftype = 0
@@ -6992,26 +7520,84 @@ else:
             if(fcompression == "none"):
                 fcompression = ""
             fcontents.seek(0, 0)
+            if(not contentasfile):
+                fcontents = fcontents.read()
             ftypehex = format(ftype, 'x').lower()
-            tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
-                          fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))]
-            AppendFileHeaderWithContent(fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs, saltkey)
+            tmpoutlist.append({'fheaders': [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
+                               fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))], 'fextradata': extradata, 'fjsoncontent': jsondata, 'fcontents': fcontents, 'fjsonchecksumtype': checksumtype[2], 'fheaderchecksumtype': checksumtype[0], 'fcontentchecksumtype': checksumtype[1]})
+        return tmpoutlist
+    def AppendFilesWithContentFromRarFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+        if(not hasattr(fp, "write")):
+            return False
+        GetDirList = AppendFilesWithContentFromRarFileToList(infile, extradata, jsondata, False, compression, compresswholefile, compressionlevel, compressionuselist, [checksumtype[2], checksumtype[3], checksumtype[3]], formatspecs, saltkey, verbose)
+        numfiles = int(len(GetDirList))
+        fnumfiles = format(numfiles, 'x').lower()
+        AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
+        try:
+            fp.flush()
+            if(hasattr(os, "sync")):
+                os.fsync(fp.fileno())
+        except (io.UnsupportedOperation, AttributeError, OSError):
+            pass
+        for curfname in GetDirList:
+            tmpoutlist = curfname['fheaders']
+            AppendFileHeaderWithContent(fp, tmpoutlist, curfname['fextradata'], curfname['fjsoncontent'], curfname['fcontents'], [curfname['fheaderchecksumtype'], curfname['fcontentchecksumtype'], curfname['fjsonchecksumtype']], formatspecs, saltkey)
             try:
                 fp.flush()
                 if(hasattr(os, "sync")):
                     os.fsync(fp.fileno())
             except (io.UnsupportedOperation, AttributeError, OSError):
                 pass
-            fcontents.close()
         return fp
 
 if(not py7zr_support):
-    def AppendFilesWithContentFromSevenZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+    def sevenzip_readall(infile, **kwargs):
         return False
 else:
+    class _MemoryIO(py7zr.Py7zIO):
+        """In-memory file object used by py7zr's factory API."""
+        def __init__(self):
+            self._buf = bytearray()
+        def write(self, data):
+            # py7zr will call this repeatedly with chunks
+            self._buf.extend(data)
+        def read(self, size=None):
+            if size is None:
+                return bytes(self._buf)
+            return bytes(self._buf[:size])
+        def seek(self, offset, whence=0):
+            # we don't really need seeking for your use case
+            return 0
+        def flush(self):
+            pass
+        def size(self):
+            return len(self._buf)
+    class _MemoryFactory(py7zr.WriterFactory):
+        """Factory that creates _MemoryIO objects and keeps them by filename."""
+        def __init__(self):
+            self.files = {}
+        def create(self, filename: str) -> py7zr.Py7zIO:
+            io_obj = _MemoryIO()
+            self.files[filename] = io_obj
+            return io_obj
+    def sevenzip_readall(infile, **kwargs):
+        """
+        Replacement for SevenZipFile.readall() using the new py7zr API.
+
+        Returns: dict[filename -> _MemoryIO]
+        """
+        factory = _MemoryFactory()
+        with py7zr.SevenZipFile(infile, mode="r", **kwargs) as archive:
+            archive.extractall(factory=factory)
+        return factory.files
+
+if(not py7zr_support):
+    def AppendFilesWithContentFromSevenZipFileToList(infile, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+        return False
     def AppendFilesWithContentFromSevenZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
-        if(not hasattr(fp, "write")):
-            return False
+        return False
+else:
+    def AppendFilesWithContentFromSevenZipFileToList(infile, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
         formver = formatspecs['format_ver']
         fileheaderver = str(int(formver.replace(".", "")))
         curinode = 0
@@ -7023,19 +7609,15 @@ else:
         if(not os.path.exists(infile) or not os.path.isfile(infile)):
             return False
         szpfp = py7zr.SevenZipFile(infile, mode="r")
-        file_content = szpfp.readall()
+        try:
+            file_content = szpfp.readall()
+        except AttributeError:
+            file_content = sevenzip_readall(infile)
         #sztest = szpfp.testzip()
         sztestalt = szpfp.test()
         if(sztestalt):
             VerbosePrintOut("Bad file found!")
-        numfiles = int(len(szpfp.list()))
-        AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
-        try:
-            fp.flush()
-            if(hasattr(os, "sync")):
-                os.fsync(fp.fileno())
-        except (io.UnsupportedOperation, AttributeError, OSError):
-            pass
+        tmpoutlist = []
         for member in sorted(szpfp.list(), key=lambda x: x.filename):
             fencoding = "UTF-8"
             if(re.findall("^[.|/]", member.filename)):
@@ -7048,19 +7630,16 @@ else:
                 fpremode = int(stat.S_IFREG | 0x1b6)
             elif(member.is_directory):
                 fpremode = int(stat.S_IFDIR | 0x1ff)
-            fwinattributes = format(int(0), 'x').lower()
+            try:
+                fwinattributes = format(int(member.attributes & 0xFFFF), 'x').lower()
+            except AttributeError:
+                fwinattributes = format(int(0), 'x').lower()
             fcompression = ""
             fcsize = format(int(0), 'x').lower()
             flinkcount = 0
             fblksize = 0
-            if(hasattr(fstatinfo, "st_blksize")):
-                fblksize = format(int(fstatinfo.st_blksize), 'x').lower()
             fblocks = 0
-            if(hasattr(fstatinfo, "st_blocks")):
-                fblocks = format(int(fstatinfo.st_blocks), 'x').lower()
             fflags = 0
-            if(hasattr(fstatinfo, "st_flags")):
-                fflags = format(int(fstatinfo.st_flags), 'x').lower()
             ftype = 0
             if(member.is_directory):
                 ftype = 5
@@ -7090,6 +7669,13 @@ else:
                     int(stat.S_IMODE(int(stat.S_IFREG | 0x1b6))), 'x').lower()
                 ftypemod = format(
                     int(stat.S_IFMT(int(stat.S_IFREG | 0x1b6))), 'x').lower()
+            try:
+                ffullmode = member.posix_mode
+                fmode = format(int(ffullmode), 'x').lower()
+                fchmode = format(int(stat.S_IMODE(ffullmode)), 'x').lower()
+                ftypemod = format(int(stat.S_IFMT(ffullmode)), 'x').lower()
+            except AttributeError:
+                pass
             try:
                 fuid = format(int(os.getuid()), 'x').lower()
             except (KeyError, AttributeError):
@@ -7127,7 +7713,10 @@ else:
                 typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, 0, False)[0]
-                file_content[member.filename].close()
+                try:
+                    file_content[member.filename].close()
+                except AttributeError:
+                    pass
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
@@ -7169,17 +7758,34 @@ else:
             if(fcompression == "none"):
                 fcompression = ""
             fcontents.seek(0, 0)
+            if(not contentasfile):
+                fcontents = fcontents.read()
             ftypehex = format(ftype, 'x').lower()
-            tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
-                          fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))]
-            AppendFileHeaderWithContent(fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs, saltkey)
+            tmpoutlist.append({'fheaders': [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
+                               fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))], 'fextradata': extradata, 'fjsoncontent': jsondata, 'fcontents': fcontents, 'fjsonchecksumtype': checksumtype[2], 'fheaderchecksumtype': checksumtype[0], 'fcontentchecksumtype': checksumtype[1]})
+        return tmpoutlist
+    def AppendFilesWithContentFromSevenZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+        if(not hasattr(fp, "write")):
+            return False
+        GetDirList = AppendFilesWithContentFromSevenZipFileToList(infile, extradata, jsondata, False, compression, compresswholefile, compressionlevel, compressionuselist, [checksumtype[2], checksumtype[3], checksumtype[3]], formatspecs, saltkey, verbose)
+        numfiles = int(len(GetDirList))
+        fnumfiles = format(numfiles, 'x').lower()
+        AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
+        try:
+            fp.flush()
+            if(hasattr(os, "sync")):
+                os.fsync(fp.fileno())
+        except (io.UnsupportedOperation, AttributeError, OSError):
+            pass
+        for curfname in GetDirList:
+            tmpoutlist = curfname['fheaders']
+            AppendFileHeaderWithContent(fp, tmpoutlist, curfname['fextradata'], curfname['fjsoncontent'], curfname['fcontents'], [curfname['fheaderchecksumtype'], curfname['fcontentchecksumtype'], curfname['fjsonchecksumtype']], formatspecs, saltkey)
             try:
                 fp.flush()
                 if(hasattr(os, "sync")):
                     os.fsync(fp.fileno())
             except (io.UnsupportedOperation, AttributeError, OSError):
                 pass
-            fcontents.close()
         return fp
 
 def AppendListsWithContent(inlist, fp, dirlistfromtxt=False, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
@@ -8449,10 +9055,8 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, file
             elif(compresscheck == "lz4" and compresscheck in compressionsupport):
                 fp = lz4.frame.open(infile, "rb")
             elif(compresscheck == "zstd" and compresscheck in compressionsupport):
-                if 'zstandard' in sys.modules:
-                    fp = ZstdFile(infile, mode="rb")
-                elif 'pyzstd' in sys.modules:
-                    fp = pyzstd.zstdfile.ZstdFile(infile, mode="rb")
+                if 'zstd' in compressionsupport:
+                    fp = zstd.ZstdFile(infile, mode="rb")
                 else:
                     return Flase
             elif((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
@@ -8569,10 +9173,8 @@ def UncompressFileAlt(fp, formatspecs=__file_format_multi_dict__, filestart=0,
     elif kind in ("lzma","xz") and (("lzma" in compressionsupport) or ("xz" in compressionsupport)):
         wrapped = lzma.LZMAFile(src)
     elif kind == "zstd"   and ("zstd" in compressionsupport or "zstandard" in compressionsupport):
-        if 'zstandard' in sys.modules:
-            wrapped = ZstdFile(fileobj=src, mode="rb")
-        elif 'pyzstd' in sys.modules:
-            wrapped = pyzstd.zstdfile.ZstdFile(fileobj=src, mode="rb")
+        if 'zstd' in compressionsupport:
+            wrapped = zstd.ZstdFile(src, mode="rb")
         else:
             return False
     elif kind == "lz4"    and "lz4"    in compressionsupport:
@@ -8640,10 +9242,8 @@ def UncompressFile(infile, formatspecs=__file_format_multi_dict__, mode="rb",
         elif (compresscheck == "bzip2" and "bzip2" in compressionsupport):
             fp = bz2.open(infile, mode)
         elif (compresscheck == "zstd" and "zstandard" in compressionsupport):
-            if 'zstandard' in sys.modules:
-                fp = ZstdFile(infile, mode=mode)
-            elif 'pyzstd' in sys.modules:
-                fp = pyzstd.zstdfile.ZstdFile(infile, mode=mode)
+            if 'zstd' in compressionsupport:
+                fp = zstd.ZstdFile(infile, mode=mode)
             else:
                 return False
         elif (compresscheck == "lz4" and "lz4" in compressionsupport):
@@ -9412,10 +10012,8 @@ def CompressOpenFile(outfile, compressionenable=True, compressionlevel=None,
             outfp = FileLikeAdapter(bz2.open(outfile, mode, compressionlevel), mode="wb")
 
         elif (fextname == ".zst" and "zstandard" in compressionsupport):
-            if 'zstandard' in sys.modules:
-                outfp = FileLikeAdapter(ZstdFile(outfile, mode=mode, level=compressionlevel), mode="wb")
-            elif 'pyzstd' in sys.modules:
-                outfp = FileLikeAdapter(pyzstd.zstdfile.ZstdFile(outfile, mode=mode, level=compressionlevel), mode="wb")
+            if 'zstd' in compressionsupport:
+                outfp = FileLikeAdapter(zstd.ZstdFile(outfile, mode=mode, level=compressionlevel), mode="wb")
             else:
                 return False  # fix: 'Flase' -> False
 
@@ -9643,7 +10241,7 @@ def CatFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__file_form
         if(not fp):
             return False
         fp.seek(filestart, 0)
-    elif(infile == "-"):
+    elif(not isinstance(infile, (list, tuple, )) and infile == "-"):
         fp = MkTempFile()
         shutil.copyfileobj(PY_STDIN_BUF, fp, length=__filebuff_size__)
         fp.seek(filestart, 0)
@@ -9732,6 +10330,7 @@ def CatFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__file_form
             formatspecs = formatspecs[compresschecking]
             fp.seek(filestart, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
+    headeroffset = fp.tell()
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelsize = len(formatspecs['format_delimiter'])
     formdel = fp.read(formdelsize).decode("UTF-8")
@@ -9739,7 +10338,6 @@ def CatFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__file_form
         return False
     if(formdel != formatspecs['format_delimiter']):
         return False
-    headeroffset = fp.tell()
     if(__use_new_style__):
         inheader = ReadFileHeaderDataBySize(fp, formatspecs['format_delimiter'])
     else:
@@ -11019,8 +11617,8 @@ def CatFileStringListFiles(instr, filestart=0, seekstart=0, seekend=0, skipcheck
     return listarrayfiles
 
 
-def TarFileListFiles(infile, verbose=False, returnfp=False):
-    if(infile == "-"):
+def TarFileListFiles(infile, formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+    if(not isinstance(infile, (list, tuple, )) and infile == "-"):
         infile = MkTempFile()
         shutil.copyfileobj(PY_STDIN_BUF, infile, length=__filebuff_size__)
         infile.seek(0, 0)
@@ -11055,10 +11653,8 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
-                if 'zstandard' in sys.modules:
-                    infile = ZstdFile(fileobj=infile, mode="rb")
-                elif 'pyzstd' in sys.modules:
-                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                if 'zstd' in compressionsupport:
+                    infile = zstd.ZstdFile(infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(fileobj=infile, mode="r")
@@ -11067,10 +11663,8 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
-                if 'zstandard' in sys.modules:
-                    infile = ZstdFile(fileobj=infile, mode="rb")
-                elif 'pyzstd' in sys.modules:
-                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                if 'zstd' in compressionsupport:
+                    infile = zstd.ZstdFile(infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(infile, "r")
@@ -11084,7 +11678,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
         ffullmode = member.mode
         flinkcount = 0
         ftype = 0
-        if(member.isreg()):
+        if(member.isreg() or member.isfile()):
             ffullmode = member.mode + stat.S_IFREG
             ftype = 0
         elif(member.islnk()):
@@ -11139,8 +11733,12 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
         return True
 
 
+def TarFileListFile(infile, formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+    return TarFileListFiles(infile, formatspecs, verbose, returnfp)
+
+
 def ZipFileListFiles(infile, verbose=False, returnfp=False):
-    if(infile == "-"):
+    if(not isinstance(infile, (list, tuple, )) and infile == "-"):
         infile = MkTempFile()
         shutil.copyfileobj(PY_STDIN_BUF, infile, length=__filebuff_size__)
         infile.seek(0, 0)
@@ -11171,35 +11769,59 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
     for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
         zipinfo = zipfp.getinfo(member.filename)
         if(zipinfo.create_system == 0 or zipinfo.create_system == 10):
-            fwinattributes = int(zipinfo.external_attr)
+            fwinattributes = int(zipinfo.external_attr & 0xFFFF)
             if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
                 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)))
+                fchmode = stat.S_IMODE(int(stat.S_IFDIR | 0x1ff))
+                ftypemod = stat.S_IFMT(int(stat.S_IFDIR | 0x1ff))
+            elif ((hasattr(member, "symlink") and member.symlink()) or member.filename.endswith('/')):
+                fmode = int(stat.S_IFREG | 0x1b6)
+                fchmode = stat.S_IMODE(int(stat.S_IFREG | 0x1b6))
+                ftypemod = stat.S_IFMT(int(stat.S_IFREG | 0x1b6))
             else:
                 fmode = int(stat.S_IFREG | 0x1b6)
-                fchmode = int(stat.S_IMODE(fmode))
-                ftypemod = int(stat.S_IFMT(fmode))
+                fchmode = stat.S_IMODE(int(stat.S_IFREG | 0x1b6))
+                ftypemod = stat.S_IFMT(int(stat.S_IFREG | 0x1b6))
         elif(zipinfo.create_system == 3):
-            fwinattributes = int(0)
-            try:
-                fmode = int(zipinfo.external_attr)
-                fchmode = stat.S_IMODE(fmode)
-                ftypemod = stat.S_IFMT(fmode)
-            except OverflowError:
-                fmode = int(zipinfo.external_attr >> 16)
-                fchmode = stat.S_IMODE(fmode)
-                ftypemod = stat.S_IFMT(fmode)
+            fwinattributes = int(zipinfo.external_attr & 0xFFFF)
+            fmode = int((zipinfo.external_attr >> 16) & 0xFFFF)
+            prefmode = int((zipinfo.external_attr >> 16) & 0xFFFF)
+            if(prefmode==0):
+                fmode = 0
+                prefmode = 0
+            else:
+                file_type = prefmode & 0xF000
+                if(file_type not in (stat.S_IFREG, stat.S_IFDIR, stat.S_IFLNK)):
+                    fmode = 0
+                    prefmode = 0
+                if((mode & 0x1FF) == 0):
+                    fmode = 0
+                    prefmode = 0
+            if (prefmode == 0):
+                if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
+                    fmode = int(stat.S_IFDIR | 0x1ff)
+                    prefmode = int(stat.S_IFDIR | 0x1ff)
+                    fchmode = stat.S_IMODE(prefmode)
+                    ftypemod = stat.S_IFMT(prefmode)
+                else:
+                    fmode = int(stat.S_IFREG | 0x1b6)
+                    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 = int(0)
+            fwinattributes = int(zipinfo.external_attr & 0xFFFF)
             if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
                 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)))
+                prefmode = int(stat.S_IFDIR | 0x1ff)
+                fchmode = stat.S_IMODE(prefmode)
+                ftypemod = stat.S_IFMT(prefmode)
             else:
                 fmode = int(stat.S_IFREG | 0x1b6)
-                fchmode = int(stat.S_IMODE(fmode))
-                ftypemod = int(stat.S_IFMT(fmode))
+                prefmode = int(stat.S_IFREG | 0x1b6)
+                fchmode = stat.S_IMODE(prefmode)
+                ftypemod = stat.S_IFMT(prefmode)
         returnval.update({lcfi: member.filename})
         if(not verbose):
             VerbosePrintOut(member.filename)
@@ -11213,10 +11835,17 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
             if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
                 ftype = 5
                 permissionstr = "d" + permissionstr
+            elif ((hasattr(member, "symlink") and member.symlink())):
+                ftype = 2
+                permissionstr = "l" + permissionstr
             else:
                 ftype = 0
                 permissionstr = "-" + permissionstr
             printfname = member.filename
+            if(ftype==2):
+                flinkname = zipfp.read(member.filename).decode("UTF-8")
+            if(ftype==2):
+                printfname = member.filename + " -> " + flinkname
             try:
                 fuid = int(os.getuid())
             except (KeyError, AttributeError):
@@ -11259,6 +11888,10 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
         return True
 
 
+def ZipFileListFile(infile, verbose=False, returnfp=False):
+    return ZipFileListFiles(infile, verbose, returnfp)
+
+
 if(not rarfile_support):
     def RarFileListFiles(infile, verbose=False, returnfp=False):
         return False
@@ -11386,6 +12019,11 @@ if(rarfile_support):
         else:
             return True
 
+
+def RarFileListFile(infile, verbose=False, returnfp=False):
+    return RarFileListFiles(infile, verbose, returnfp)
+
+
 if(not py7zr_support):
     def SevenZipFileListFiles(infile, verbose=False, returnfp=False):
         return False
@@ -11397,7 +12035,10 @@ if(py7zr_support):
         lcfi = 0
         returnval = {}
         szpfp = py7zr.SevenZipFile(infile, mode="r")
-        file_content = szpfp.readall()
+        try:
+            file_content = szpfp.readall()
+        except AttributeError:
+            file_content = sevenzip_readall(infile)
         #sztest = szpfp.testzip()
         sztestalt = szpfp.test()
         if(sztestalt):
@@ -11420,6 +12061,13 @@ if(py7zr_support):
                 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)))
+            try:
+                ffullmode = member.posix_mode
+                fmode = format(int(ffullmode), 'x').lower()
+                fchmode = format(int(stat.S_IMODE(ffullmode)), 'x').lower()
+                ftypemod = format(int(stat.S_IFMT(ffullmode)), 'x').lower()
+            except AttributeError:
+                pass
             returnval.update({lcfi: member.filename})
             if(not verbose):
                 VerbosePrintOut(member.filename)
@@ -11441,7 +12089,10 @@ if(py7zr_support):
                     printfname = member.filename
                 if(ftype == 0):
                     fsize = len(file_content[member.filename].read())
-                    file_content[member.filename].close()
+                    try:
+                        file_content[member.filename].close()
+                    except AttributeError:
+                        pass
                 try:
                     fuid = int(os.getuid())
                 except (KeyError, AttributeError):
@@ -11484,12 +12135,16 @@ if(py7zr_support):
             return True
 
 
+def SevenZipFileListFile(infile, verbose=False, returnfp=False):
+    return SevenZipFileListFiles(infile, verbose, returnfp)
+
+
 def InFileListFiles(infile, verbose=False, formatspecs=__file_format_multi_dict__, seektoend=False, newstyle=False, returnfp=False):
     checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-        return TarFileListFiles(infile, verbose, returnfp)
+        return TarFileListFiles(infile, formatspecs, verbose, returnfp)
     elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
         return ZipFileListFiles(infile, verbose, returnfp)
     elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
@@ -11503,6 +12158,10 @@ def InFileListFiles(infile, verbose=False, formatspecs=__file_format_multi_dict_
     return False
 
 
+def InFileListFile(infile, verbose=False, formatspecs=__file_format_multi_dict__, seektoend=False, newstyle=False, returnfp=False):
+    return InFileListFiles(infile, verbose, formatspecs, seektoend, newstyle, returnfp)
+
+
 def ListDirListFiles(infiles, dirlistfromtxt=False, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
     outarray = MkTempFile()
     packform = PackCatFile(infiles, outarray, dirlistfromtxt, compression, compresswholefile,
@@ -11511,6 +12170,11 @@ def ListDirListFiles(infiles, dirlistfromtxt=False, compression="auto", compress
         outarray, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, returnfp)
     return listarrayfiles
 
+
+def ListDirListFiles(infiles, dirlistfromtxt=False, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
+    return ListDirListFiles(infiles, dirlistfromtxt, compression, compresswholefile, compressionlevel, followlink, seekstart, seekend, skipchecksum, checksumtype, formatspecs, seektoend, verbose, returnfp)
+
+
 def detect_cwd(ftp, file_dir):
     """
     Test whether cwd into file_dir works. Returns True if it does,
@@ -13576,7 +14240,6 @@ def run_http_file_server(fileobj, url, on_progress=None, backlog=5):
             if not ah or not ah.strip().lower().startswith("basic "):
                 return False
             try:
-                import base64
                 b64 = ah.strip().split(" ", 1)[1]
                 raw = base64.b64decode(_to_bytes(b64))
                 try: raw_txt = raw.decode("utf-8")