PyCatFile 0.15.16__tar.gz → 0.15.18__tar.gz

{pycatfile-0.15.16 → pycatfile-0.15.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyCatFile
-Version: 0.15.16
+Version: 0.15.18
 Summary: A tar like file format name catfile after unix cat command (concatenate files) .
 Home-page: https://github.com/GameMaker2k/PyCatFile
 Download-URL: https://github.com/GameMaker2k/PyCatFile/archive/master.tar.gz

{pycatfile-0.15.16 → pycatfile-0.15.18}/PyCatFile.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyCatFile
-Version: 0.15.16
+Version: 0.15.18
 Summary: A tar like file format name catfile after unix cat command (concatenate files) .
 Home-page: https://github.com/GameMaker2k/PyCatFile
 Download-URL: https://github.com/GameMaker2k/PyCatFile/archive/master.tar.gz

{pycatfile-0.15.16 → pycatfile-0.15.18}/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: 12/25/2024 Ver. 0.15.16 RC 1 - Author: cooldude2k $
+    $FileInfo: pycatfile.py - Last Update: 12/26/2024 Ver. 0.15.18 RC 1 - Author: cooldude2k $
 '''
 
 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
@@ -314,12 +314,12 @@ __file_format_dict__ = {'format_name': __file_format_name__, 'format_magic': __f
                         'format_delimiter': __file_format_delimiter__, 'format_ver': __file_format_ver__, 'new_style': __use_new_style__, 'use_advanced_list': __use_advanced_list__, 'use_alt_inode': __use_alt_inode__}
 __project__ = __program_name__
 __project_url__ = "https://github.com/GameMaker2k/PyCatFile"
-__version_info__ = (0, 15, 16, "RC 1", 1)
-__version_date_info__ = (2024, 12, 25, "RC 1", 1)
+__version_info__ = (0, 15, 18, "RC 1", 1)
+__version_date_info__ = (2024, 12, 26, "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: e3bae7488c237d5480aaf274033b0730fad054fc $"
+__revision_id__ = "$Id: 64d8dc9d309e4604a335dee0bc50e5679540be3f $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -386,6 +386,7 @@ except ImportError:
     pass
 try:
     import zstandard
+    compressionsupport.append("zst")
     compressionsupport.append("zstd")
     compressionsupport.append("zstandard")
 except ImportError:
@@ -402,6 +403,8 @@ except ImportError:
     except ImportError:
         pass
 compressionsupport.append("zlib")
+compressionsupport.append("zl")
+compressionsupport.append("zz")
 
 compressionlist = ['auto']
 compressionlistalt = []
@@ -1003,6 +1006,193 @@ class GzipFile:
         self.close()
 
 
+class ZstdFile(object):
+    ZSTD_MAGIC = b'\x28\xb5\x2f\xfd'  # Zstandard magic bytes
+
+    def __init__(self, file_path=None, fileobj=None, mode='rb', level=9,
+                 encoding=None, errors=None, newline=None):
+        """
+        A file-like wrapper around Zstandard compression/decompression,
+        supporting both Python 2 and 3.
+        """
+        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")
+
+        self.file_path = file_path
+        self.fileobj = fileobj
+        self.mode = mode
+        self.level = level
+        self.encoding = encoding
+        self.errors = errors
+        self.newline = newline
+        self._compressed_data = b''
+        self._decompressed_data = b''
+        self._position = 0
+
+        # Track whether we're doing text mode
+        self._text_mode = 't' in mode
+
+        # Force binary mode internally for reading/writing bytes
+        internal_mode = mode.replace('t', 'b')
+
+        if 'w' in mode or 'a' in mode or 'x' in mode:
+            # Open the file if a path was specified; otherwise, use fileobj
+            if file_path:
+                self.file = open(file_path, internal_mode)
+            else:
+                self.file = fileobj
+
+            # Create a ZstdCompressor, then obtain a compressobj for flushing
+            zctx = zstandard.ZstdCompressor(level=self.level)
+            self._compressor = zctx.compressobj()
+
+        elif 'r' in mode:
+            if file_path:
+                if os.path.exists(file_path):
+                    self.file = open(file_path, internal_mode)
+                    self._load_file()
+                else:
+                    raise FileNotFoundError("No such file: '{}'".format(file_path))
+            else:
+                # fileobj provided
+                self.file = fileobj
+                self._load_file()
+
+        else:
+            raise ValueError("Mode should be 'rb'/'rt' or 'wb'/'wt'")
+
+    def _load_file(self):
+        """
+        Reads the entire compressed file into memory and uses streaming
+        decompression to handle multiple frames or frames with unknown size.
+        """
+        self.file.seek(0)
+        self._compressed_data = self.file.read()
+
+        # Validate Zstd magic bytes at the start
+        if not self._compressed_data.startswith(self.ZSTD_MAGIC):
+            raise ValueError("Invalid Zstandard file header (magic bytes missing)")
+
+        # Use streaming decompression (stream_reader)
+        decompressor = zstandard.ZstdDecompressor()
+        reader = decompressor.stream_reader(io.BytesIO(self._compressed_data))
+
+        chunks = []
+        while True:
+            chunk = reader.read(16384)  # 16 KB at a time
+            if not chunk:
+                break
+            chunks.append(chunk)
+
+        self._decompressed_data = b"".join(chunks)
+
+        # If in text mode, decode the bytes
+        if self._text_mode:
+            enc = self.encoding or 'UTF-8'
+            err = self.errors or 'strict'
+            self._decompressed_data = self._decompressed_data.decode(enc, err)
+
+    def write(self, data):
+        """
+        Write data to the ZstdFile. In text mode, data is encoded;
+        in binary mode, data is written as bytes. Each call to `write()`
+        produces compressed chunks.
+        """
+        if self._text_mode:
+            # Encode data from str (Py3) or unicode (Py2) to bytes
+            data = data.encode(self.encoding or 'UTF-8', self.errors or 'strict')
+
+        # Compress the chunk with the compressobj
+        compressed_chunk = self._compressor.compress(data)
+        if compressed_chunk:
+            self.file.write(compressed_chunk)
+
+    def read(self, size=-1):
+        """
+        Read from the decompressed data buffer.
+        """
+        if size < 0:
+            size = len(self._decompressed_data) - self._position
+        data = self._decompressed_data[self._position:self._position + size]
+        self._position += size
+        return data
+
+    def seek(self, offset, whence=0):
+        """
+        Adjust the current read position in the decompressed data buffer.
+        """
+        if whence == 0:  # absolute
+            new_pos = offset
+        elif whence == 1:  # relative
+            new_pos = self._position + offset
+        elif whence == 2:  # relative to end
+            new_pos = len(self._decompressed_data) + offset
+        else:
+            raise ValueError("Invalid value for whence")
+
+        self._position = max(0, min(new_pos, len(self._decompressed_data)))
+
+    def tell(self):
+        """
+        Return the current read position in the decompressed data buffer.
+        """
+        return self._position
+
+    def flush(self):
+        """
+        Flush the underlying file object. This doesn't force the Zstd
+        compressor to flush partial data like zlib, but we can at least
+        flush the OS buffer.
+        """
+        self.file.flush()
+
+    def fileno(self):
+        """
+        Return the file descriptor if available.
+        """
+        if hasattr(self.file, 'fileno'):
+            return self.file.fileno()
+        raise OSError("The underlying file object does not support fileno()")
+
+    def isatty(self):
+        """
+        Return whether the underlying file is a TTY.
+        """
+        if hasattr(self.file, 'isatty'):
+            return self.file.isatty()
+        return False
+
+    def truncate(self, size=None):
+        """
+        Truncate the underlying file if possible.
+        """
+        if hasattr(self.file, 'truncate'):
+            return self.file.truncate(size)
+        raise OSError("The underlying file object does not support truncate()")
+
+    def close(self):
+        """
+        If in write mode, finalize by flushing any remaining compressed data
+        in the compressobj. Then close the file if we opened it.
+        """
+        if any(x in self.mode for x in ('w', 'a', 'x')):
+            # flush() returns any remaining compressed data in the compressobj
+            final_chunk = self._compressor.flush()
+            if final_chunk:
+                self.file.write(final_chunk)
+
+        if self.file_path:
+            self.file.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+
 '''
 class BloscFile:
  def __init__(self, file_path=None, fileobj=None, mode='rb', level=9, encoding=None, errors=None, newline=None):
@@ -1795,7 +1985,7 @@ def ReadFileHeaderDataBySizeWithContent(fp, listonly=False, uncompress=True, ski
     else:
         fcontents.seek(0, 0)
         if(uncompress):
-            fcontents = UncompressBytesAltFPFP(fcontents, formatspecs)
+            fcontents = UncompressArchiveFile(fcontents, formatspecs)
     fcontentend = fp.tell()
     if(re.findall("^\\+([0-9]+)", fseeknextfile)):
         fseeknextasnum = int(fseeknextfile.replace("+", ""))
@@ -1908,7 +2098,7 @@ def ReadFileHeaderDataBySizeWithContentToArray(fp, listonly=False, contentasfile
     else:
         fcontents.seek(0, 0)
         if(uncompress):
-            fcontents = UncompressBytesAltFP(fcontents, formatspecs)
+            fcontents = UncompressArchiveFile(fcontents, formatspecs)
             fcontents.seek(0, 0)
             fccs = GetFileChecksum(
                 fcontents.read(), HeaderOut[-3].lower(), False, formatspecs)
@@ -2030,7 +2220,7 @@ def ReadFileHeaderDataBySizeWithContentToList(fp, listonly=False, uncompress=Tru
     else:
         fcontents.seek(0, 0)
         if(uncompress):
-            fcontents = UncompressBytesAltFP(fcontents, formatspecs)
+            fcontents = UncompressArchiveFile(fcontents, formatspecs)
             fcontents.seek(0, 0)
     fcontentend = fp.tell() - 1
     if(re.findall("^\\+([0-9]+)", fseeknextfile)):
@@ -2306,7 +2496,7 @@ def ReadInFileBySizeWithContentToArray(infile, seekstart=0, seekend=0, listonly=
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         fp = infile
         fp.seek(0, 0)
-        fp = UncompressBytesAltFP(fp, formatspecs)
+        fp = UncompressArchiveFile(fp, formatspecs)
         checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
             return False
@@ -2320,13 +2510,13 @@ def ReadInFileBySizeWithContentToArray(infile, seekstart=0, seekend=0, listonly=
         else:
             shutil.copyfileobj(sys.stdin, fp)
         fp.seek(0, 0)
-        fp = UncompressBytesAltFP(fp, formatspecs)
+        fp = UncompressArchiveFile(fp, formatspecs)
         if(not fp):
             return False
         fp.seek(0, 0)
     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
         fp = download_file_from_internet_file(infile)
-        fp = UncompressBytesAltFP(fp, formatspecs)
+        fp = UncompressArchiveFile(fp, formatspecs)
         fp.seek(0, 0)
         if(not fp):
             return False
@@ -2369,7 +2559,7 @@ def ReadInFileBySizeWithContentToList(infile, seekstart=0, seekend=0, listonly=F
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         fp = infile
         fp.seek(0, 0)
-        fp = UncompressBytesAltFP(fp, formatspecs)
+        fp = UncompressArchiveFile(fp, formatspecs)
         checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
             return False
@@ -2383,13 +2573,13 @@ def ReadInFileBySizeWithContentToList(infile, seekstart=0, seekend=0, listonly=F
         else:
             shutil.copyfileobj(sys.stdin, fp)
         fp.seek(0, 0)
-        fp = UncompressBytesAltFP(fp, formatspecs)
+        fp = UncompressArchiveFile(fp, formatspecs)
         if(not fp):
             return False
         fp.seek(0, 0)
     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
         fp = download_file_from_internet_file(infile)
-        fp = UncompressBytesAltFP(fp, formatspecs)
+        fp = UncompressArchiveFile(fp, formatspecs)
         fp.seek(0, 0)
         if(not fp):
             return False
@@ -3201,27 +3391,27 @@ def CheckCompressionType(infile, formatspecs=__file_format_dict__, closefp=True)
     prefp = catfp.read(2)
     if(prefp == binascii.unhexlify("1f8b")):
         filetype = "gzip"
-    if(prefp == binascii.unhexlify("7801")):
+    elif(prefp == binascii.unhexlify("7801")):
         filetype = "zlib"
-    if(prefp == binascii.unhexlify("785e")):
+    elif(prefp == binascii.unhexlify("785e")):
         filetype = "zlib"
-    if(prefp == binascii.unhexlify("789c")):
+    elif(prefp == binascii.unhexlify("789c")):
         filetype = "zlib"
-    if(prefp == binascii.unhexlify("78da")):
+    elif(prefp == binascii.unhexlify("78da")):
         filetype = "zlib"
     catfp.seek(0, 0)
     prefp = catfp.read(3)
     if(prefp == binascii.unhexlify("425a68")):
         filetype = "bzip2"
-    if(prefp == binascii.unhexlify("5d0000")):
+    elif(prefp == binascii.unhexlify("5d0000")):
         filetype = "lzma"
     catfp.seek(0, 0)
     prefp = catfp.read(4)
     if(prefp == binascii.unhexlify("28b52ffd")):
         filetype = "zstd"
-    if(prefp == binascii.unhexlify("04224d18")):
+    elif(prefp == binascii.unhexlify("04224d18")):
         filetype = "lz4"
-    if(prefp == binascii.unhexlify("504B0304")):
+    elif(prefp == binascii.unhexlify("504B0304")):
         filetype = "zipfile"
     catfp.seek(0, 0)
     prefp = catfp.read(5)
@@ -3231,13 +3421,13 @@ def CheckCompressionType(infile, formatspecs=__file_format_dict__, closefp=True)
     prefp = catfp.read(6)
     if(prefp == binascii.unhexlify("fd377a585a00")):
         filetype = "lzma"
-    if(prefp == binascii.unhexlify("377abcaf271c")):
+    elif(prefp == binascii.unhexlify("377abcaf271c")):
         filetype = "7zipfile"
     catfp.seek(0, 0)
     prefp = catfp.read(7)
     if(prefp == binascii.unhexlify("526172211a0700")):
         filetype = "rarfile"
-    if(prefp == binascii.unhexlify("43617446696c65")):
+    elif(prefp == binascii.unhexlify("43617446696c65")):
         filetype = "catfile"
     catfp.seek(0, 0)
     prefp = catfp.read(8)
@@ -3259,7 +3449,7 @@ def CheckCompressionType(infile, formatspecs=__file_format_dict__, closefp=True)
     if(filetype == "gzip" or filetype == "bzip2" or filetype == "lzma" or filetype == "zstd" or filetype == "lz4" or filetype == "zlib"):
         if(TarFileCheck(catfp)):
             filetype = "tarfile"
-    if(not filetype):
+    elif(not filetype):
         if(TarFileCheck(catfp)):
             filetype = "tarfile"
         elif(zipfile.is_zipfile(catfp)):
@@ -3300,22 +3490,24 @@ def GetCompressionMimeType(infile, formatspecs=__file_format_dict__):
     compresscheck = CheckCompressionType(fp, formatspecs, False)
     if(compresscheck == "gzip" or compresscheck == "gz"):
         return archivefile_gzip_mimetype
-    if(compresscheck == "zlib" or (compresscheck == "zz" or compresscheck == "zl" or compresscheck == "zlib")):
+    elif(compresscheck == "zlib" or (compresscheck == "zz" or compresscheck == "zl" or compresscheck == "zlib")):
         return archivefile_zlib_mimetype
-    if(compresscheck == "bzip2" or compresscheck == "bz2"):
+    elif(compresscheck == "bzip2" or compresscheck == "bz2"):
         return archivefile_bzip2_mimetype
-    if(compresscheck == "zstd" or compresscheck == "zstandard"):
+    elif(compresscheck == "zstd" or compresscheck == "zstandard"):
         return archivefile_zstandard_mimetype
-    if(compresscheck == "lz4"):
+    elif(compresscheck == "lz4"):
         return archivefile_lz4_mimetype
-    if(compresscheck == "lzo" or compresscheck == "lzop"):
+    elif(compresscheck == "lzo" or compresscheck == "lzop"):
         return archivefile_lzop_mimetype
-    if(compresscheck == "lzma"):
+    elif(compresscheck == "lzma"):
         return archivefile_lzma_mimetype
-    if(compresscheck == "xz"):
+    elif(compresscheck == "xz"):
         return archivefile_xz_mimetype
-    if(compresscheck == "catfile" or compresscheck == "cat" or compresscheck == formatspecs['format_lower']):
+    elif(compresscheck == "catfile" or compresscheck == "cat" or compresscheck == formatspecs['format_lower']):
         return archivefile_cat_mimetype
+    else:
+        return False
     if(not compresscheck):
         return False
     return False
@@ -3331,7 +3523,7 @@ def UncompressArchiveFile(fp, formatspecs=__file_format_dict__):
     elif(compresscheck == "bzip2" and compresscheck in compressionsupport):
         catfp = bz2.BZ2File(fp)
     elif(compresscheck == "zstd" and compresscheck in compressionsupport):
-        catfp = zstandard.ZstdDecompressor().stream_reader(fp)
+        catfp = ZstdFile(fileobj=fp, mode="rb")
     elif(compresscheck == "lz4" and compresscheck in compressionsupport):
         catfp = lz4.frame.LZ4FrameFile(fp, mode='rb')
     elif((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
@@ -3365,27 +3557,28 @@ def UncompressFile(infile, formatspecs=__file_format_dict__, mode="rb"):
     if(sys.version_info[0] == 2 and compresscheck):
         if(mode == "rt"):
             mode = "r"
-        if(mode == "wt"):
+        elif(mode == "wt"):
             mode = "w"
     try:
         if(compresscheck == "gzip" and compresscheck in compressionsupport):
             filefp = gzip.open(infile, mode)
-        if(compresscheck == "bzip2" and compresscheck in compressionsupport):
+        elif(compresscheck == "bzip2" and compresscheck in compressionsupport):
             filefp = bz2.open(infile, mode)
-        if(compresscheck == "zstd" and compresscheck in compressionsupport):
-            decompressor = zstandard.ZstdDecompressor()
-            filefp = decompressor.open(infile, mode)
-        if(compresscheck == "lz4" and compresscheck in compressionsupport):
+        elif(compresscheck == "zstd" and compresscheck in compressionsupport):
+            filefp = ZstdFile(infile, mode=mode)
+        elif(compresscheck == "lz4" and compresscheck in compressionsupport):
             filefp = lz4.frame.open(infile, mode)
-        if((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
+        elif((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
             filefp = lzo.open(infile, mode)
-        if((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
+        elif((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
             filefp = lzma.open(infile, mode)
-        if(compresscheck == "zlib" and compresscheck in compressionsupport):
+        elif(compresscheck == "zlib" and compresscheck in compressionsupport):
             filefp = ZlibFile(infile, mode=mode)
-        if(compresscheck == "catfile" or compresscheck == formatspecs['format_lower']):
+        elif(compresscheck == "catfile" or compresscheck == formatspecs['format_lower']):
             filefp = open(infile, mode)
-        if(not compresscheck):
+        elif(not compresscheck):
+            filefp = open(infile, mode)
+        else:
             filefp = open(infile, mode)
     except FileNotFoundError:
         return False
@@ -3400,20 +3593,22 @@ def UncompressString(infile, formatspecs=__file_format_dict__):
     compresscheck = CheckCompressionTypeFromString(infile, formatspecs, False)
     if(compresscheck == "gzip" and compresscheck in compressionsupport):
         fileuz = GzipDecompressData(infile)
-    if(compresscheck == "bzip2" and compresscheck in compressionsupport):
+    elif(compresscheck == "bzip2" and compresscheck in compressionsupport):
         fileuz = BzipDecompressData(infile)
-    if(compresscheck == "zstd" and compresscheck in compressionsupport):
+    elif(compresscheck == "zstd" and compresscheck in compressionsupport):
         decompressor = zstandard.ZstdDecompressor()
         fileuz = decompressor.decompress(infile)
-    if(compresscheck == "lz4" and compresscheck in compressionsupport):
+    elif(compresscheck == "lz4" and compresscheck in compressionsupport):
         fileuz = lz4.frame.decompress(infile)
-    if((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
+    elif((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
         fileuz = lzo.decompress(infile)
-    if((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
+    elif((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
         fileuz = lzma.decompress(infile)
-    if(compresscheck == "zlib" and compresscheck in compressionsupport):
+    elif(compresscheck == "zlib" and compresscheck in compressionsupport):
         fileuz = zlib.decompress(infile)
-    if(not compresscheck):
+    elif(not compresscheck):
+        fileuz = infile
+    else:
         fileuz = infile
     if(hasattr(fileuz, 'decode')):
         fileuz = fileuz.decode("UTF-8")
@@ -3446,20 +3641,22 @@ def UncompressBytes(infile, formatspecs=__file_format_dict__):
     compresscheck = CheckCompressionTypeFromBytes(infile, formatspecs, False)
     if(compresscheck == "gzip" and compresscheck in compressionsupport):
         fileuz = GzipDecompressData(infile)
-    if(compresscheck == "bzip2" and compresscheck in compressionsupport):
+    elif(compresscheck == "bzip2" and compresscheck in compressionsupport):
         fileuz = BzipDecompressData(infile)
-    if(compresscheck == "zstd" and compresscheck in compressionsupport):
+    elif(compresscheck == "zstd" and compresscheck in compressionsupport):
         decompressor = zstandard.ZstdDecompressor()
         fileuz = decompressor.decompress(infile)
-    if(compresscheck == "lz4" and compresscheck in compressionsupport):
+    elif(compresscheck == "lz4" and compresscheck in compressionsupport):
         fileuz = lz4.frame.decompress(infile)
-    if((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
+    elif((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
         fileuz = lzo.decompress(infile)
-    if((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
+    elif((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
         fileuz = lzma.decompress(infile)
-    if(compresscheck == "zlib" and compresscheck in compressionsupport):
+    elif(compresscheck == "zlib" and compresscheck in compressionsupport):
         fileuz = zlib.decompress(infile)
-    if(not compresscheck):
+    elif(not compresscheck):
+        fileuz = infile
+    else:
         fileuz = infile
     return fileuz
 
@@ -3538,7 +3735,7 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_dict__, closefp=Tr
     if(py7zr_support and compresscheck == "7zipfile" and py7zr.is_7zfile(infile)):
         return "7zipfile"
     if(hasattr(infile, "read") or hasattr(infile, "write")):
-        catfp = UncompressBytesAltFP(infile, formatspecs['format_lower'])
+        catfp = UncompressArchiveFile(infile, formatspecs['format_lower'])
     else:
         try:
             if(compresscheck == "gzip" and compresscheck in compressionsupport):
@@ -3548,7 +3745,7 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_dict__, closefp=Tr
             elif(compresscheck == "lz4" and compresscheck in compressionsupport):
                 catfp = lz4.frame.open(infile, "rb")
             elif(compresscheck == "zstd" and compresscheck in compressionsupport):
-                catfp = zstandard.open(infile, "rb")
+                catfp = ZstdFile(infile, mode="rb")
             elif((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
                 catfp = lzo.open(infile, "rb")
             elif((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
@@ -3598,7 +3795,7 @@ def CompressArchiveFile(fp, compression="auto", compressionlevel=None, formatspe
             compressionlevel = int(compressionlevel)
         catfp.write(GzipCompressData(
             fp.read(), compresslevel=compressionlevel))
-    if(compression == "bzip2" and compression in compressionsupport):
+    elif(compression == "bzip2" and compression in compressionsupport):
         catfp = BytesIO()
         if(compressionlevel is None):
             compressionlevel = 9
@@ -3606,7 +3803,7 @@ def CompressArchiveFile(fp, compression="auto", compressionlevel=None, formatspe
             compressionlevel = int(compressionlevel)
         catfp.write(BzipCompressData(
             fp.read(), compresslevel=compressionlevel))
-    if(compression == "lz4" and compression in compressionsupport):
+    elif(compression == "lz4" and compression in compressionsupport):
         catfp = BytesIO()
         if(compressionlevel is None):
             compressionlevel = 9
@@ -3614,14 +3811,14 @@ def CompressArchiveFile(fp, compression="auto", compressionlevel=None, formatspe
             compressionlevel = int(compressionlevel)
         catfp.write(lz4.frame.compress(
             fp.read(), compression_level=compressionlevel))
-    if((compression == "lzo" or compression == "lzop") and compression in compressionsupport):
+    elif((compression == "lzo" or compression == "lzop") and compression in compressionsupport):
         catfp = BytesIO()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
             compressionlevel = int(compressionlevel)
         catfp.write(lzo.compress(fp.read(), compresslevel=compressionlevel))
-    if(compression == "zstd" and compression in compressionsupport):
+    elif(compression == "zstd" and compression in compressionsupport):
         catfp = BytesIO()
         if(compressionlevel is None):
             compressionlevel = 9
@@ -3629,7 +3826,7 @@ def CompressArchiveFile(fp, compression="auto", compressionlevel=None, formatspe
             compressionlevel = int(compressionlevel)
         compressor = zstandard.ZstdCompressor(compressionlevel, threads=get_default_threads())
         catfp.write(compressor.compress(fp.read()))
-    if(compression == "lzma" and compression in compressionsupport):
+    elif(compression == "lzma" and compression in compressionsupport):
         catfp = BytesIO()
         if(compressionlevel is None):
             compressionlevel = 9
@@ -3639,7 +3836,7 @@ def CompressArchiveFile(fp, compression="auto", compressionlevel=None, formatspe
             catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_ALONE, filters=[{"id": lzma.FILTER_LZMA1, "preset": compressionlevel}]))
         except (NotImplementedError, lzma.LZMAError):
             catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_ALONE))
-    if(compression == "xz" and compression in compressionsupport):
+    elif(compression == "xz" and compression in compressionsupport):
         catfp = BytesIO()
         if(compressionlevel is None):
             compressionlevel = 9
@@ -3649,14 +3846,16 @@ def CompressArchiveFile(fp, compression="auto", compressionlevel=None, formatspe
             catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_XZ, filters=[{"id": lzma.FILTER_LZMA2, "preset": compressionlevel}]))
         except (NotImplementedError, lzma.LZMAError):
             catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_XZ))
-    if(compression == "zlib" and compression in compressionsupport):
+    elif(compression == "zlib" and compression in compressionsupport):
         catfp = BytesIO()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
             compressionlevel = int(compressionlevel)
         catfp.write(zlib.compress(fp.read(), compressionlevel))
-    if(compression == "auto" or compression is None):
+    elif(compression == "auto" or compression is None):
+        catfp = fp
+    else:
         catfp = fp
     catfp.seek(0, 0)
     return catfp
@@ -3687,8 +3886,7 @@ def CompressOpenFile(outfile, compressionenable=True, compressionlevel=None):
         elif(fextname == ".bz2" and "bzip2" in compressionsupport):
             outfp = bz2.open(outfile, mode, compressionlevel)
         elif(fextname == ".zst" and "zstandard" in compressionsupport):
-            outfp = zstandard.open(
-                    outfile, mode, zstandard.ZstdCompressor(level=compressionlevel, threads=get_default_threads()))
+            outfp = ZstdFile(outfile, mode=mode, level=compressionlevel)
         elif(fextname == ".xz" and "xz" in compressionsupport):
             try:
                 outfp = lzma.open(outfile, mode, format=lzma.FORMAT_XZ, filters=[{"id": lzma.FILTER_LZMA2, "preset": compressionlevel}])
@@ -5239,7 +5437,7 @@ def ArchiveFileSeekToFileNum(infile, seekto=0, listonly=False, contentasfile=Tru
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         catfp = infile
         catfp.seek(0, 0)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, seekto, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
@@ -5261,7 +5459,7 @@ def ArchiveFileSeekToFileNum(infile, seekto=0, listonly=False, contentasfile=Tru
         else:
             shutil.copyfileobj(sys.stdin, catfp)
         catfp.seek(0, 0)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
@@ -5269,14 +5467,14 @@ def ArchiveFileSeekToFileNum(infile, seekto=0, listonly=False, contentasfile=Tru
         catfp = BytesIO()
         catfp.write(infile)
         catfp.seek(0, 0)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
         catfp = download_file_from_internet_file(infile)
         catfp.seek(0, 0)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
@@ -5506,7 +5704,7 @@ def ArchiveFileSeekToFileName(infile, seekfile=None, listonly=False, contentasfi
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         catfp = infile
         catfp.seek(0, 0)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
@@ -5528,7 +5726,7 @@ def ArchiveFileSeekToFileName(infile, seekfile=None, listonly=False, contentasfi
         else:
             shutil.copyfileobj(sys.stdin, catfp)
         catfp.seek(0, 0)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
@@ -5536,13 +5734,13 @@ def ArchiveFileSeekToFileName(infile, seekfile=None, listonly=False, contentasfi
         catfp = BytesIO()
         catfp.write(infile)
         catfp.seek(0, 0)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
         catfp = download_file_from_internet_file(infile)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         catfp.seek(0, 0)
         if(not catfp):
             return False
@@ -5786,7 +5984,7 @@ def ArchiveFileValidate(infile, formatspecs=__file_format_dict__, verbose=False,
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         catfp = infile
         catfp.seek(0, 0)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, 0, 0, False, True, False, formatspecs, returnfp)
@@ -5808,7 +6006,7 @@ def ArchiveFileValidate(infile, formatspecs=__file_format_dict__, verbose=False,
         else:
             shutil.copyfileobj(sys.stdin, catfp)
         catfp.seek(0, 0)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
@@ -5816,13 +6014,13 @@ def ArchiveFileValidate(infile, formatspecs=__file_format_dict__, verbose=False,
         catfp = BytesIO()
         catfp.write(infile)
         catfp.seek(0, 0)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
         catfp = download_file_from_internet_file(infile)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         catfp.seek(0, 0)
         if(not catfp):
             return False
@@ -6073,7 +6271,7 @@ def ArchiveFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentas
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         catfp = infile
         catfp.seek(0, 0)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
@@ -6095,7 +6293,7 @@ def ArchiveFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentas
         else:
             shutil.copyfileobj(sys.stdin, catfp)
         catfp.seek(0, 0)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
@@ -6103,13 +6301,13 @@ def ArchiveFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentas
         catfp = BytesIO()
         catfp.write(infile)
         catfp.seek(0, 0)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
         catfp = download_file_from_internet_file(infile)
-        catfp = UncompressBytesAltFP(catfp, formatspecs)
+        catfp = UncompressArchiveFile(catfp, formatspecs)
         catfp.seek(0, 0)
         if(not catfp):
             return False
@@ -6377,7 +6575,7 @@ def ArchiveFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentas
             else:
                 catfcontents.seek(0, 0)
                 if(uncompress):
-                    catfcontents = UncompressBytesAltFP(
+                    catfcontents = UncompressArchiveFile(
                         catfcontents, formatspecs)
                     catfcontents.seek(0, 0)
                     catfccs = GetFileChecksum(
@@ -9444,7 +9642,7 @@ def download_file_from_internet_file(url, headers=geturls_headers_pycatfile_pyth
 def download_file_from_internet_uncompress_file(url, headers=geturls_headers_pycatfile_python_alt, formatspecs=__file_format_dict__):
     formatspecs = FormatSpecsListToDict(formatspecs)
     fp = download_file_from_internet_file(url)
-    fp = UncompressBytesAltFP(fp, formatspecs)
+    fp = UncompressArchiveFile(fp, formatspecs)
     fp.seek(0, 0)
     if(not fp):
         return False
@@ -9470,7 +9668,7 @@ def download_file_from_internet_string(url, headers=geturls_headers_pycatfile_py
 def download_file_from_internet_uncompress_string(url, headers=geturls_headers_pycatfile_python_alt, formatspecs=__file_format_dict__):
     formatspecs = FormatSpecsListToDict(formatspecs)
     fp = download_file_from_internet_string(url)
-    fp = UncompressBytesAltFP(fp, formatspecs)
+    fp = UncompressArchiveFile(fp, formatspecs)
     fp.seek(0, 0)
     if(not fp):
         return False