PyCatFile 0.15.14__tar.gz → 0.15.16__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyCatFile
-Version: 0.15.14
+Version: 0.15.16
 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.14 → pycatfile-0.15.16}/PyCatFile.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyCatFile
-Version: 0.15.14
+Version: 0.15.16
 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.14 → pycatfile-0.15.16}/pycatfile.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
+# -*- coding: UTF-8 -*-
 
 '''
     This program is free software; you can redistribute it and/or modify
@@ -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/21/2024 Ver. 0.15.14 RC 1 - Author: cooldude2k $
+    $FileInfo: pycatfile.py - Last Update: 12/25/2024 Ver. 0.15.16 RC 1 - Author: cooldude2k $
 '''
 
 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
@@ -94,13 +94,13 @@ except ImportError:
 # Windows-specific setup
 if os.name == 'nt':
     if sys.version_info[0] == 2:
-        sys.stdout = codecs.getwriter('utf-8')(sys.stdout)
-        sys.stderr = codecs.getwriter('utf-8')(sys.stderr)
+        sys.stdout = codecs.getwriter('UTF-8')(sys.stdout)
+        sys.stderr = codecs.getwriter('UTF-8')(sys.stderr)
     else:
         sys.stdout = io.TextIOWrapper(
-            sys.stdout.buffer, encoding='utf-8', errors='replace', line_buffering=True)
+            sys.stdout.buffer, encoding='UTF-8', errors='replace', line_buffering=True)
         sys.stderr = io.TextIOWrapper(
-            sys.stderr.buffer, encoding='utf-8', errors='replace', line_buffering=True)
+            sys.stderr.buffer, encoding='UTF-8', errors='replace', line_buffering=True)
 
 hashlib_guaranteed = False
 # Environment setup
@@ -225,6 +225,16 @@ def get_importing_script_path():
             return os.path.abspath(filename)
     return None
 
+def get_default_threads():
+    """Returns the number of CPU threads available, or 1 if unavailable."""
+    try:
+        cpu_threads = os.cpu_count()
+        return cpu_threads if cpu_threads is not None else 1
+    except AttributeError:
+        # os.cpu_count() might not be available in some environments
+        return 1
+
+
 __use_pysftp__ = False
 __use_alt_format__ = False
 __use_env_file__ = True
@@ -253,7 +263,7 @@ if os.path.exists(__config_file__) and __use_ini_file__:
         if sys.version_info[0] < 3:  # Python 2
             return value.decode('unicode_escape')
         else:  # Python 3
-            return bytes(value, 'utf-8').decode('unicode_escape')
+            return bytes(value, 'UTF-8').decode('unicode_escape')
     __file_format_name__ = config.get('main', 'name')
     __program_name__ = config.get('main', 'proname')
     __file_format_lower__ = config.get('main', 'lower')
@@ -304,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, 14, "RC 1", 1)
-__version_date_info__ = (2024, 12, 21, "RC 1", 1)
+__version_info__ = (0, 15, 16, "RC 1", 1)
+__version_date_info__ = (2024, 12, 25, "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: 5ac437d67d0b485df434560f6f73d2823777d4c1 $"
+__revision_id__ = "$Id: e3bae7488c237d5480aaf274033b0730fad054fc $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -340,14 +350,14 @@ geturls_ua_pycatfile_python_alt = "Mozilla/5.0 ({osver}; {archtype}; +{prourl})
 )+" "+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)"
 geturls_ua_googlebot_google_old = "Googlebot/2.1 (+http://www.google.com/bot.html)"
-geturls_headers_pycatfile_python = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_pycatfile_python, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6", 'Accept-Charset': "ISO-8859-1,ISO-8859-15,utf-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close",
+geturls_headers_pycatfile_python = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_pycatfile_python, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6", 'Accept-Charset': "ISO-8859-1,ISO-8859-15,UTF-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close",
                                     'SEC-CH-UA': "\""+__project__+"\";v=\""+str(__version__)+"\", \"Not;A=Brand\";v=\"8\", \""+py_implementation+"\";v=\""+str(platform.release())+"\"", 'SEC-CH-UA-FULL-VERSION': str(__version__), 'SEC-CH-UA-PLATFORM': ""+py_implementation+"", 'SEC-CH-UA-ARCH': ""+platform.machine()+"", 'SEC-CH-UA-PLATFORM': str(__version__), 'SEC-CH-UA-BITNESS': str(PyBitness)}
-geturls_headers_pycatfile_python_alt = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_pycatfile_python_alt, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6", 'Accept-Charset': "ISO-8859-1,ISO-8859-15,utf-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close",
+geturls_headers_pycatfile_python_alt = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_pycatfile_python_alt, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6", 'Accept-Charset': "ISO-8859-1,ISO-8859-15,UTF-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close",
                                         'SEC-CH-UA': "\""+__project__+"\";v=\""+str(__version__)+"\", \"Not;A=Brand\";v=\"8\", \""+py_implementation+"\";v=\""+str(platform.release())+"\"", 'SEC-CH-UA-FULL-VERSION': str(__version__), 'SEC-CH-UA-PLATFORM': ""+py_implementation+"", 'SEC-CH-UA-ARCH': ""+platform.machine()+"", 'SEC-CH-UA-PLATFORM': str(__version__), 'SEC-CH-UA-BITNESS': str(PyBitness)}
 geturls_headers_googlebot_google = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_googlebot_google, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6",
-                                    'Accept-Charset': "ISO-8859-1,ISO-8859-15,utf-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close"}
+                                    'Accept-Charset': "ISO-8859-1,ISO-8859-15,UTF-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close"}
 geturls_headers_googlebot_google_old = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_googlebot_google_old, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6",
-                                        'Accept-Charset': "ISO-8859-1,ISO-8859-15,utf-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close"}
+                                        'Accept-Charset': "ISO-8859-1,ISO-8859-15,UTF-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close"}
 
 compressionsupport = []
 try:
@@ -598,7 +608,7 @@ def ListDir(dirpath, followlink=False, duplicates=False, include_regex=None, exc
     elif isinstance(dirpath, basestring):
         dirpath = list(filter(None, [dirpath]))
     retlist = []
-    fs_encoding = sys.getfilesystemencoding() or 'utf-8'
+    fs_encoding = sys.getfilesystemencoding() or 'UTF-8'
     include_pattern = re.compile(include_regex) if include_regex else None
     exclude_pattern = re.compile(exclude_regex) if exclude_regex else None
     for mydirfile in dirpath:
@@ -665,7 +675,7 @@ def ListDirAdvanced(dirpath, followlink=False, duplicates=False, include_regex=N
     elif isinstance(dirpath, basestring):
         dirpath = list(filter(None, [dirpath]))
     retlist = []
-    fs_encoding = sys.getfilesystemencoding() or 'utf-8'
+    fs_encoding = sys.getfilesystemencoding() or 'UTF-8'
     include_pattern = re.compile(include_regex) if include_regex else None
     exclude_pattern = re.compile(exclude_regex) if exclude_regex else None
     for mydirfile in dirpath:
@@ -813,11 +823,11 @@ class ZlibFile:
             self._compressed_data, self.wbits)
         if self._text_mode:
             self._decompressed_data = self._decompressed_data.decode(
-                self.encoding or 'utf-8', self.errors or 'strict')
+                self.encoding or 'UTF-8', self.errors or 'strict')
 
     def write(self, data):
         if self._text_mode:
-            data = data.encode(self.encoding or 'utf-8',
+            data = data.encode(self.encoding or 'UTF-8',
                                self.errors or 'strict')
         compressed_data = self._compressor.compress(
             data) + self._compressor.flush(zlib.Z_SYNC_FLUSH)
@@ -928,11 +938,11 @@ class GzipFile:
         self._decompressed_data = gzip.decompress(self._compressed_data)
         if self._text_mode:
             self._decompressed_data = self._decompressed_data.decode(
-                self.encoding or 'utf-8', self.errors or 'strict')
+                self.encoding or 'UTF-8', self.errors or 'strict')
 
     def write(self, data):
         if self._text_mode:
-            data = data.encode(self.encoding or 'utf-8',
+            data = data.encode(self.encoding or 'UTF-8',
                                self.errors or 'strict')
         compressed_data = self._compressor.compress(data)
         self.file.write(compressed_data)
@@ -1039,11 +1049,11 @@ class BloscFile:
    raise ValueError("Invalid blosc file header");
   self._decompressed_data = blosc.decompress(self._compressed_data);
   if self._text_mode:
-   self._decompressed_data = self._decompressed_data.decode(self.encoding or 'utf-8', self.errors or 'strict');
+   self._decompressed_data = self._decompressed_data.decode(self.encoding or 'UTF-8', self.errors or 'strict');
 
  def write(self, data):
   if self._text_mode:
-   data = data.encode(self.encoding or 'utf-8', self.errors or 'strict');
+   data = data.encode(self.encoding or 'UTF-8', self.errors or 'strict');
   compressed_data = blosc.compress(data, cname='blosclz', clevel=self.level);
   self.file.write(compressed_data);
   self.file.flush();
@@ -1146,11 +1156,11 @@ class BrotliFile:
    raise ValueError("Invalid brotli file header");
   self._decompressed_data = brotli.decompress(self._compressed_data);
   if self._text_mode:
-   self._decompressed_data = self._decompressed_data.decode(self.encoding or 'utf-8', self.errors or 'strict');
+   self._decompressed_data = self._decompressed_data.decode(self.encoding or 'UTF-8', self.errors or 'strict');
 
  def write(self, data):
   if self._text_mode:
-   data = data.encode(self.encoding or 'utf-8', self.errors or 'strict');
+   data = data.encode(self.encoding or 'UTF-8', self.errors or 'strict');
   compressed_data = self._compressor.process(data);
   self.file.write(compressed_data);
   self.file.flush();
@@ -1785,7 +1795,7 @@ def ReadFileHeaderDataBySizeWithContent(fp, listonly=False, uncompress=True, ski
     else:
         fcontents.seek(0, 0)
         if(uncompress):
-            fcontents = UncompressArchiveFile(fcontents, formatspecs)
+            fcontents = UncompressBytesAltFPFP(fcontents, formatspecs)
     fcontentend = fp.tell()
     if(re.findall("^\\+([0-9]+)", fseeknextfile)):
         fseeknextasnum = int(fseeknextfile.replace("+", ""))
@@ -1898,7 +1908,7 @@ def ReadFileHeaderDataBySizeWithContentToArray(fp, listonly=False, contentasfile
     else:
         fcontents.seek(0, 0)
         if(uncompress):
-            fcontents = UncompressArchiveFile(fcontents, formatspecs)
+            fcontents = UncompressBytesAltFP(fcontents, formatspecs)
             fcontents.seek(0, 0)
             fccs = GetFileChecksum(
                 fcontents.read(), HeaderOut[-3].lower(), False, formatspecs)
@@ -2020,7 +2030,7 @@ def ReadFileHeaderDataBySizeWithContentToList(fp, listonly=False, uncompress=Tru
     else:
         fcontents.seek(0, 0)
         if(uncompress):
-            fcontents = UncompressArchiveFile(fcontents, formatspecs)
+            fcontents = UncompressBytesAltFP(fcontents, formatspecs)
             fcontents.seek(0, 0)
     fcontentend = fp.tell() - 1
     if(re.findall("^\\+([0-9]+)", fseeknextfile)):
@@ -2296,7 +2306,7 @@ def ReadInFileBySizeWithContentToArray(infile, seekstart=0, seekend=0, listonly=
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         fp = infile
         fp.seek(0, 0)
-        fp = UncompressArchiveFile(fp, formatspecs)
+        fp = UncompressBytesAltFP(fp, formatspecs)
         checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
             return False
@@ -2310,13 +2320,13 @@ def ReadInFileBySizeWithContentToArray(infile, seekstart=0, seekend=0, listonly=
         else:
             shutil.copyfileobj(sys.stdin, fp)
         fp.seek(0, 0)
-        fp = UncompressArchiveFile(fp, formatspecs)
+        fp = UncompressBytesAltFP(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 = UncompressArchiveFile(fp, formatspecs)
+        fp = UncompressBytesAltFP(fp, formatspecs)
         fp.seek(0, 0)
         if(not fp):
             return False
@@ -2359,7 +2369,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 = UncompressArchiveFile(fp, formatspecs)
+        fp = UncompressBytesAltFP(fp, formatspecs)
         checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
             return False
@@ -2373,13 +2383,13 @@ def ReadInFileBySizeWithContentToList(infile, seekstart=0, seekend=0, listonly=F
         else:
             shutil.copyfileobj(sys.stdin, fp)
         fp.seek(0, 0)
-        fp = UncompressArchiveFile(fp, formatspecs)
+        fp = UncompressBytesAltFP(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 = UncompressArchiveFile(fp, formatspecs)
+        fp = UncompressBytesAltFP(fp, formatspecs)
         fp.seek(0, 0)
         if(not fp):
             return False
@@ -2785,6 +2795,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                         ilcsize = []
                         while(ilmin < ilsize):
                             cfcontents = BytesIO()
+                            fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
@@ -2801,18 +2812,18 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                                     ilcsize.append(sys.maxsize)
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
-                        compression = compressionlistalt[ilcmin]
+                        curcompression = compressionlistalt[ilcmin]
                     fcontents.seek(0, 0)
                     cfcontents = BytesIO()
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressArchiveFile(
-                        cfcontents, compression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
                         fcsize = format(int(cfsize), 'x').lower()
-                        fcompression = compression
+                        fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
         if(followlink and (ftype == 1 or ftype == 2)):
@@ -2829,6 +2840,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                         ilcsize = []
                         while(ilmin < ilsize):
                             cfcontents = BytesIO()
+                            fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
@@ -2845,18 +2857,18 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                                     ilcsize.append(sys.maxsize)
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
-                        compression = compressionlistalt[ilcmin]
+                        curcompression = compressionlistalt[ilcmin]
                     fcontents.seek(0, 0)
                     cfcontents = BytesIO()
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressArchiveFile(
-                        cfcontents, compression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
                         fcsize = format(int(cfsize), 'x').lower()
-                        fcompression = compression
+                        fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
         if(fcompression == "none"):
@@ -3273,6 +3285,16 @@ def CheckCompressionTypeFromString(instring, formatspecs=__file_format_dict__, c
     return CheckCompressionType(instringsfile, formatspecs, closefp)
 
 
+def CheckCompressionTypeFromBytes(instring, formatspecs=__file_format_dict__, closefp=True):
+    formatspecs = FormatSpecsListToDict(formatspecs)
+    try:
+        instringsfile = BytesIO(instring)
+    except TypeError:
+        instringsfile = BytesIO(instring.decode("UTF-8"))
+    return CheckCompressionType(instringsfile, formatspecs, closefp)
+
+
+
 def GetCompressionMimeType(infile, formatspecs=__file_format_dict__):
     formatspecs = FormatSpecsListToDict(formatspecs)
     compresscheck = CheckCompressionType(fp, formatspecs, False)
@@ -3309,7 +3331,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 = zstd.ZstdDecompressor().stream_reader(fp)
+        catfp = zstandard.ZstdDecompressor().stream_reader(fp)
     elif(compresscheck == "lz4" and compresscheck in compressionsupport):
         catfp = lz4.frame.LZ4FrameFile(fp, mode='rb')
     elif((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
@@ -3347,47 +3369,24 @@ def UncompressFile(infile, formatspecs=__file_format_dict__, mode="rb"):
             mode = "w"
     try:
         if(compresscheck == "gzip" and compresscheck in compressionsupport):
-            try:
-                filefp = gzip.open(infile, mode, encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                filefp = gzip.open(infile, mode)
+            filefp = gzip.open(infile, mode)
         if(compresscheck == "bzip2" and compresscheck in compressionsupport):
-            try:
-                filefp = bz2.open(infile, mode, encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                filefp = bz2.open(infile, mode)
+            filefp = bz2.open(infile, mode)
         if(compresscheck == "zstd" and compresscheck in compressionsupport):
-            try:
-                filefp = zstandard.open(infile, mode, encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                filefp = zstandard.open(infile, mode)
+            decompressor = zstandard.ZstdDecompressor()
+            filefp = decompressor.open(infile, mode)
         if(compresscheck == "lz4" and compresscheck in compressionsupport):
-            try:
-                filefp = lz4.frame.open(infile, mode, encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                filefp = lz4.frame.open(infile, mode)
+            filefp = lz4.frame.open(infile, mode)
         if((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
-            try:
-                filefp = lzo.open(infile, mode, encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                filefp = lzo.open(infile, mode)
+            filefp = lzo.open(infile, mode)
         if((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
-            try:
-                filefp = lzma.open(infile, mode, encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                filefp = lzma.open(infile, mode)
+            filefp = lzma.open(infile, mode)
         if(compresscheck == "zlib" and compresscheck in compressionsupport):
             filefp = ZlibFile(infile, mode=mode)
         if(compresscheck == "catfile" or compresscheck == formatspecs['format_lower']):
-            try:
-                filefp = open(infile, mode, encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                filefp = open(infile, mode)
+            filefp = open(infile, mode)
         if(not compresscheck):
-            try:
-                filefp = open(infile, mode, encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                filefp = open(infile, mode)
+            filefp = open(infile, mode)
     except FileNotFoundError:
         return False
     try:
@@ -3397,18 +3396,15 @@ def UncompressFile(infile, formatspecs=__file_format_dict__, mode="rb"):
     return filefp
 
 
-def UncompressString(infile):
+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):
         fileuz = BzipDecompressData(infile)
     if(compresscheck == "zstd" and compresscheck in compressionsupport):
-        try:
-            import zstandard
-        except ImportError:
-            return False
-        fileuz = zstandard.decompress(infile)
+        decompressor = zstandard.ZstdDecompressor()
+        fileuz = decompressor.decompress(infile)
     if(compresscheck == "lz4" and compresscheck in compressionsupport):
         fileuz = lz4.frame.decompress(infile)
     if((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
@@ -3424,9 +3420,68 @@ def UncompressString(infile):
     return fileuz
 
 
-def UncompressStringAlt(infile):
+def UncompressStringAlt(instring, formatspecs=__file_format_dict__):
+    filefp = StringIO()
+    outstring = UncompressString(instring, formatspecs)
+    filefp.write(outstring)
+    filefp.seek(0, 0)
+    return filefp
+
+def UncompressStringAltFP(fp, formatspecs=__file_format_dict__):
+    if(not hasattr(fp, "read")):
+        return False
+    prechck = CheckCompressionType(fp, formatspecs, False)
+    fp.seek(0, 0)
+    if(prechck!="zstd"):
+        return UncompressArchiveFile(fp, formatspecs)
     filefp = StringIO()
-    outstring = UncompressString(infile)
+    fp.seek(0, 0)
+    outstring = UncompressString(fp.read(), formatspecs)
+    filefp.write(outstring)
+    filefp.seek(0, 0)
+    return filefp
+
+
+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):
+        fileuz = BzipDecompressData(infile)
+    if(compresscheck == "zstd" and compresscheck in compressionsupport):
+        decompressor = zstandard.ZstdDecompressor()
+        fileuz = decompressor.decompress(infile)
+    if(compresscheck == "lz4" and compresscheck in compressionsupport):
+        fileuz = lz4.frame.decompress(infile)
+    if((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
+        fileuz = lzo.decompress(infile)
+    if((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
+        fileuz = lzma.decompress(infile)
+    if(compresscheck == "zlib" and compresscheck in compressionsupport):
+        fileuz = zlib.decompress(infile)
+    if(not compresscheck):
+        fileuz = infile
+    return fileuz
+
+
+def UncompressBytesAlt(inbytes, formatspecs=__file_format_dict__):
+    filefp = BytesIO()
+    outstring = UncompressBytes(inbytes, formatspecs)
+    filefp.write(outstring)
+    filefp.seek(0, 0)
+    return filefp
+
+
+def UncompressBytesAltFP(fp, formatspecs=__file_format_dict__):
+    if(not hasattr(fp, "read")):
+        return False
+    prechck = CheckCompressionType(fp, formatspecs, False)
+    fp.seek(0, 0)
+    if(prechck!="zstd"):
+        return UncompressArchiveFile(fp, formatspecs)
+    filefp = BytesIO()
+    fp.seek(0, 0)
+    outstring = UncompressBytes(fp.read(), formatspecs)
     filefp.write(outstring)
     filefp.seek(0, 0)
     return filefp
@@ -3483,7 +3538,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 = UncompressArchiveFile(infile, formatspecs['format_lower'])
+        catfp = UncompressBytesAltFP(infile, formatspecs['format_lower'])
     else:
         try:
             if(compresscheck == "gzip" and compresscheck in compressionsupport):
@@ -3569,26 +3624,31 @@ def CompressArchiveFile(fp, compression="auto", compressionlevel=None, formatspe
     if(compression == "zstd" and compression in compressionsupport):
         catfp = BytesIO()
         if(compressionlevel is None):
-            compressionlevel = 10
+            compressionlevel = 9
         else:
             compressionlevel = int(compressionlevel)
-        catfp.write(zstandard.compress(fp.read(), level=compressionlevel))
+        compressor = zstandard.ZstdCompressor(compressionlevel, threads=get_default_threads())
+        catfp.write(compressor.compress(fp.read()))
     if(compression == "lzma" and compression in compressionsupport):
         catfp = BytesIO()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
             compressionlevel = int(compressionlevel)
-        catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_ALONE, filters=[
-                    {"id": lzma.FILTER_LZMA1, "preset": compressionlevel}]))
+        try:
+            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):
         catfp = BytesIO()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
             compressionlevel = int(compressionlevel)
-        catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_XZ, filters=[
-                    {"id": lzma.FILTER_LZMA2, "preset": compressionlevel}]))
+        try:
+            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):
         catfp = BytesIO()
         if(compressionlevel is None):
@@ -3611,10 +3671,8 @@ def CompressOpenFile(outfile, compressionenable=True, compressionlevel=None):
         return False
     fbasename = os.path.splitext(outfile)[0]
     fextname = os.path.splitext(outfile)[1]
-    if(compressionlevel is None and fextname != ".zst"):
+    if(compressionlevel is None):
         compressionlevel = 9
-    elif(compressionlevel is None and fextname == ".zst"):
-        compressionlevel = 10
     else:
         compressionlevel = int(compressionlevel)
     if(sys.version_info[0] == 2):
@@ -3623,56 +3681,29 @@ def CompressOpenFile(outfile, compressionenable=True, compressionlevel=None):
         mode = "wb"
     try:
         if(fextname not in outextlistwd or not compressionenable):
-            try:
-                outfp = open(outfile, "wb", encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                outfp = open(outfile, "wb")
+            outfp = open(outfile, "wb")
         elif(fextname == ".gz" and "gzip" in compressionsupport):
-            try:
-                outfp = gzip.open(
-                    outfile, mode, compressionlevel, encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                outfp = gzip.open(outfile, mode, compressionlevel)
+            outfp = gzip.open(outfile, mode, compressionlevel)
         elif(fextname == ".bz2" and "bzip2" in compressionsupport):
-            try:
-                outfp = bz2.open(
-                    outfile, mode, compressionlevel, encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                outfp = bz2.open(outfile, mode, compressionlevel)
+            outfp = bz2.open(outfile, mode, compressionlevel)
         elif(fextname == ".zst" and "zstandard" in compressionsupport):
-            try:
-                outfp = zstandard.open(outfile, mode, zstandard.ZstdCompressor(
-                    level=compressionlevel), encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                outfp = zstandard.open(
-                    outfile, mode, zstandard.ZstdCompressor(level=compressionlevel))
+            outfp = zstandard.open(
+                    outfile, mode, zstandard.ZstdCompressor(level=compressionlevel, threads=get_default_threads()))
         elif(fextname == ".xz" and "xz" in compressionsupport):
             try:
-                outfp = lzma.open(outfile, mode, format=lzma.FORMAT_XZ, filters=[
-                                  {"id": lzma.FILTER_LZMA2, "preset": compressionlevel}], encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                outfp = lzma.open(outfile, mode, format=lzma.FORMAT_XZ, filters=[
-                                  {"id": lzma.FILTER_LZMA2, "preset": compressionlevel}])
+                outfp = lzma.open(outfile, mode, format=lzma.FORMAT_XZ, filters=[{"id": lzma.FILTER_LZMA2, "preset": compressionlevel}])
+            except (NotImplementedError, lzma.LZMAError):
+                outfp = lzma.open(outfile, mode, format=lzma.FORMAT_XZ)
         elif(fextname == ".lz4" and "lz4" in compressionsupport):
-            try:
-                outfp = lz4.frame.open(
-                    outfile, mode, compression_level=compressionlevel, encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                outfp = lz4.frame.open(
+            outfp = lz4.frame.open(
                     outfile, mode, compression_level=compressionlevel)
         elif(fextname == ".lzo" and "lzop" in compressionsupport):
-            try:
-                outfp = lzo.open(
-                    outfile, mode, compresslevel=compressionlevel, encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                outfp = lzo.open(outfile, mode, compresslevel=compressionlevel)
+            outfp = lzo.open(outfile, mode, compresslevel=compressionlevel)
         elif(fextname == ".lzma" and "lzma" in compressionsupport):
             try:
-                outfp = lzma.open(outfile, mode, format=lzma.FORMAT_ALONE, filters=[
-                                  {"id": lzma.FILTER_LZMA1, "preset": compressionlevel}], encoding="UTF-8")
-            except (ValueError, TypeError) as e:
-                outfp = lzma.open(outfile, mode, format=lzma.FORMAT_ALONE, filters=[
-                                  {"id": lzma.FILTER_LZMA1, "preset": compressionlevel}])
+                outfp = lzma.open(outfile, mode, format=lzma.FORMAT_ALONE, filters=[{"id": lzma.FILTER_LZMA1, "preset": compressionlevel}])
+            except (NotImplementedError, lzma.LZMAError):
+                outfp = lzma.open(outfile, mode, format=lzma.FORMAT_ALONE)
         elif((fextname == ".zz" or fextname == ".zl" or fextname == ".zlib") and "zlib" in compressionsupport):
             outfp = ZlibFile(outfile, mode=mode, level=compressionlevel)
     except FileNotFoundError:
@@ -3970,6 +4001,7 @@ def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, compression="auto",
                         ilcsize = []
                         while(ilmin < ilsize):
                             cfcontents = BytesIO()
+                            fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
@@ -3986,18 +4018,18 @@ def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, compression="auto",
                                     ilcsize.append(sys.maxsize)
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
-                        compression = compressionlistalt[ilcmin]
+                        curcompression = compressionlistalt[ilcmin]
                     fcontents.seek(0, 0)
                     cfcontents = BytesIO()
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressArchiveFile(
-                        cfcontents, compression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
                         fcsize = format(int(cfsize), 'x').lower()
-                        fcompression = compression
+                        fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
         if(fcompression == "none"):
@@ -4016,6 +4048,7 @@ def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, compression="auto",
                         ilcsize = []
                         while(ilmin < ilsize):
                             cfcontents = BytesIO()
+                            fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
@@ -4032,18 +4065,18 @@ def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, compression="auto",
                                     ilcsize.append(sys.maxsize)
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
-                        compression = compressionlistalt[ilcmin]
+                        curcompression = compressionlistalt[ilcmin]
                     fcontents.seek(0, 0)
                     cfcontents = BytesIO()
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressArchiveFile(
-                        cfcontents, compression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
                         fcsize = format(int(cfsize), 'x').lower()
-                        fcompression = compression
+                        fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
         fcontents.seek(0, 0)
@@ -4268,48 +4301,49 @@ def PackArchiveFileFromTarFile(infile, outfile, compression="auto", compresswhol
         fcsize = format(int(0), 'x').lower()
         fcontents = BytesIO()
         if ftype in data_types:
-            with tarfp.extractfile(member) as fpc:
-                shutil.copyfileobj(fpc, fcontents)
-                if(not compresswholefile):
-                    fcontents.seek(0, 2)
-                    ucfsize = fcontents.tell()
-                    fcontents.seek(0, 0)
-                    if(compression == "auto"):
-                        ilsize = len(compressionlistalt)
-                        ilmin = 0
-                        ilcsize = []
-                        while(ilmin < ilsize):
-                            cfcontents = BytesIO()
-                            shutil.copyfileobj(fcontents, cfcontents)
-                            fcontents.seek(0, 0)
-                            cfcontents.seek(0, 0)
-                            cfcontents = CompressArchiveFile(
-                                cfcontents, compressionlistalt[ilmin], compressionlevel, formatspecs)
-                            if(cfcontents):
-                                cfcontents.seek(0, 2)
-                                ilcsize.append(cfcontents.tell())
-                                cfcontents.close()
-                            else:
-                                try:
-                                    ilcsize.append(sys.maxint)
-                                except AttributeError:
-                                    ilcsize.append(sys.maxsize)
-                            ilmin = ilmin + 1
-                        ilcmin = ilcsize.index(min(ilcsize))
-                        compression = compressionlistalt[ilcmin]
-                    fcontents.seek(0, 0)
-                    cfcontents = BytesIO()
-                    shutil.copyfileobj(fcontents, cfcontents)
-                    cfcontents.seek(0, 0)
-                    cfcontents = CompressArchiveFile(
-                        cfcontents, compression, compressionlevel, formatspecs)
-                    cfcontents.seek(0, 2)
-                    cfsize = cfcontents.tell()
-                    if(ucfsize > cfsize):
-                        fcsize = format(int(cfsize), 'x').lower()
-                        fcompression = compression
-                        fcontents.close()
-                        fcontents = cfcontents
+            fpc = tarfp.extractfile(member)
+            shutil.copyfileobj(fpc, fcontents)
+            if(not compresswholefile):
+                fcontents.seek(0, 2)
+                ucfsize = fcontents.tell()
+                fcontents.seek(0, 0)
+                if(compression == "auto"):
+                    ilsize = len(compressionlistalt)
+                    ilmin = 0
+                    ilcsize = []
+                    while(ilmin < ilsize):
+                        cfcontents = BytesIO()
+                        fcontents.seek(0, 0)
+                        shutil.copyfileobj(fcontents, cfcontents)
+                        fcontents.seek(0, 0)
+                        cfcontents.seek(0, 0)
+                        cfcontents = CompressArchiveFile(
+                            cfcontents, compressionlistalt[ilmin], compressionlevel, formatspecs)
+                        if(cfcontents):
+                            cfcontents.seek(0, 2)
+                            ilcsize.append(cfcontents.tell())
+                            cfcontents.close()
+                        else:
+                            try:
+                                ilcsize.append(sys.maxint)
+                            except AttributeError:
+                                ilcsize.append(sys.maxsize)
+                        ilmin = ilmin + 1
+                    ilcmin = ilcsize.index(min(ilcsize))
+                    curcompression = compressionlistalt[ilcmin]
+                fcontents.seek(0, 0)
+                cfcontents = BytesIO()
+                shutil.copyfileobj(fcontents, cfcontents)
+                cfcontents.seek(0, 0)
+                cfcontents = CompressArchiveFile(
+                    cfcontents, curcompression, compressionlevel, formatspecs)
+                cfcontents.seek(0, 2)
+                cfsize = cfcontents.tell()
+                if(ucfsize > cfsize):
+                    fcsize = format(int(cfsize), 'x').lower()
+                    fcompression = curcompression
+                    fcontents.close()
+                    fcontents = cfcontents
         if(fcompression == "none"):
             fcompression = ""
         fcontents.seek(0, 0)
@@ -4443,16 +4477,16 @@ def PackArchiveFileFromZipFile(infile, outfile, compression="auto", compresswhol
         zipinfo = zipfp.getinfo(member.filename)
         if(verbose):
             VerbosePrintOut(fname)
-        if(not member.is_dir()):
-            fpremode = int(stat.S_IFREG + 438)
-        elif(member.is_dir()):
+        if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
             fpremode = int(stat.S_IFDIR + 511)
+        else:
+            fpremode = int(stat.S_IFREG + 438)
         flinkcount = 0
         ftype = 0
-        if(not member.is_dir()):
-            ftype = 0
-        elif(member.is_dir()):
+        if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
             ftype = 5
+        else:
+            ftype = 0
         flinkname = ""
         fcurfid = format(int(curfid), 'x').lower()
         fcurinode = format(int(curfid), 'x').lower()
@@ -4476,14 +4510,14 @@ def PackArchiveFileFromZipFile(infile, outfile, compression="auto", compresswhol
             int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower()
         if(zipinfo.create_system == 0 or zipinfo.create_system == 10):
             fwinattributes = format(int(zipinfo.external_attr), 'x').lower()
-            if(not member.is_dir()):
-                fmode = format(int(stat.S_IFREG + 438), 'x').lower()
-                fchmode = stat.S_IMODE(int(stat.S_IFREG + 438))
-                ftypemod = stat.S_IFMT(int(stat.S_IFREG + 438))
-            elif(member.is_dir()):
+            if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
                 fmode = format(int(stat.S_IFDIR + 511), 'x').lower()
                 fchmode = stat.S_IMODE(int(stat.S_IFDIR + 511))
                 ftypemod = stat.S_IFMT(int(stat.S_IFDIR + 511))
+            else:
+                fmode = format(int(stat.S_IFREG + 438), 'x').lower()
+                fchmode = stat.S_IMODE(int(stat.S_IFREG + 438))
+                ftypemod = stat.S_IFMT(int(stat.S_IFREG + 438))
         elif(zipinfo.create_system == 3):
             fwinattributes = format(int(0), 'x').lower()
             try:
@@ -4498,16 +4532,16 @@ def PackArchiveFileFromZipFile(infile, outfile, compression="auto", compresswhol
                 ftypemod = stat.S_IFMT(prefmode)
         else:
             fwinattributes = format(int(0), 'x').lower()
-            if(not member.is_dir()):
-                fmode = format(int(stat.S_IFREG + 438), 'x').lower()
-                prefmode = int(stat.S_IFREG + 438)
-                fchmode = stat.S_IMODE(prefmode)
-                ftypemod = stat.S_IFMT(prefmode)
-            elif(member.is_dir()):
+            if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
                 fmode = format(int(stat.S_IFDIR + 511), 'x').lower()
                 prefmode = int(stat.S_IFDIR + 511)
                 fchmode = stat.S_IMODE(prefmode)
                 ftypemod = stat.S_IFMT(prefmode)
+            else:
+                fmode = format(int(stat.S_IFREG + 438), 'x').lower()
+                prefmode = int(stat.S_IFREG + 438)
+                fchmode = stat.S_IMODE(prefmode)
+                ftypemod = stat.S_IFMT(prefmode)
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
         try:
@@ -4558,6 +4592,7 @@ def PackArchiveFileFromZipFile(infile, outfile, compression="auto", compresswhol
                     ilcsize = []
                     while(ilmin < ilsize):
                         cfcontents = BytesIO()
+                        fcontents.seek(0, 0)
                         shutil.copyfileobj(fcontents, cfcontents)
                         fcontents.seek(0, 0)
                         cfcontents.seek(0, 0)
@@ -4568,18 +4603,18 @@ def PackArchiveFileFromZipFile(infile, outfile, compression="auto", compresswhol
                         cfcontents.close()
                         ilmin = ilmin + 1
                     ilcmin = ilcsize.index(min(ilcsize))
-                    compression = compressionlistalt[ilcmin]
+                    curcompression = compressionlistalt[ilcmin]
                 fcontents.seek(0, 0)
                 cfcontents = BytesIO()
                 shutil.copyfileobj(fcontents, cfcontents)
                 cfcontents.seek(0, 0)
                 cfcontents = CompressArchiveFile(
-                    cfcontents, compression, compressionlevel, formatspecs)
+                    cfcontents, curcompression, compressionlevel, formatspecs)
                 cfcontents.seek(0, 2)
                 cfsize = cfcontents.tell()
                 if(ucfsize > cfsize):
                     fcsize = format(int(cfsize), 'x').lower()
-                    fcompression = compression
+                    fcompression = curcompression
                     fcontents.close()
                     fcontents = cfcontents
         if(fcompression == "none"):
@@ -4855,6 +4890,7 @@ if(rarfile_support):
                         ilcsize = []
                         while(ilmin < ilsize):
                             cfcontents = BytesIO()
+                            fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
@@ -4871,13 +4907,13 @@ if(rarfile_support):
                                     ilcsize.append(sys.maxsize)
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
-                        compression = compressionlistalt[ilcmin]
+                        curcompression = compressionlistalt[ilcmin]
                     fcontents.seek(0, 0)
                     cfcontents = BytesIO()
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressArchiveFile(
-                        cfcontents, compression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
@@ -5090,6 +5126,7 @@ if(py7zr_support):
                         ilcsize = []
                         while(ilmin < ilsize):
                             cfcontents = BytesIO()
+                            fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
@@ -5106,18 +5143,18 @@ if(py7zr_support):
                                     ilcsize.append(sys.maxsize)
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
-                        compression = compressionlistalt[ilcmin]
+                        curcompression = compressionlistalt[ilcmin]
                     fcontents.seek(0, 0)
                     cfcontents = BytesIO()
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressArchiveFile(
-                        cfcontents, compression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
                         fcsize = format(int(cfsize), 'x').lower()
-                        fcompression = compression
+                        fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
             if(fcompression == "none"):
@@ -5202,7 +5239,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 = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(catfp, formatspecs)
         checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, seekto, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
@@ -5224,7 +5261,7 @@ def ArchiveFileSeekToFileNum(infile, seekto=0, listonly=False, contentasfile=Tru
         else:
             shutil.copyfileobj(sys.stdin, catfp)
         catfp.seek(0, 0)
-        catfp = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
@@ -5232,14 +5269,14 @@ def ArchiveFileSeekToFileNum(infile, seekto=0, listonly=False, contentasfile=Tru
         catfp = BytesIO()
         catfp.write(infile)
         catfp.seek(0, 0)
-        catfp = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(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 = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
@@ -5469,7 +5506,7 @@ def ArchiveFileSeekToFileName(infile, seekfile=None, listonly=False, contentasfi
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         catfp = infile
         catfp.seek(0, 0)
-        catfp = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(catfp, formatspecs)
         checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
@@ -5491,7 +5528,7 @@ def ArchiveFileSeekToFileName(infile, seekfile=None, listonly=False, contentasfi
         else:
             shutil.copyfileobj(sys.stdin, catfp)
         catfp.seek(0, 0)
-        catfp = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
@@ -5499,13 +5536,13 @@ def ArchiveFileSeekToFileName(infile, seekfile=None, listonly=False, contentasfi
         catfp = BytesIO()
         catfp.write(infile)
         catfp.seek(0, 0)
-        catfp = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(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 = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(catfp, formatspecs)
         catfp.seek(0, 0)
         if(not catfp):
             return False
@@ -5749,7 +5786,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 = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(catfp, formatspecs)
         checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, 0, 0, False, True, False, formatspecs, returnfp)
@@ -5771,7 +5808,7 @@ def ArchiveFileValidate(infile, formatspecs=__file_format_dict__, verbose=False,
         else:
             shutil.copyfileobj(sys.stdin, catfp)
         catfp.seek(0, 0)
-        catfp = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
@@ -5779,13 +5816,13 @@ def ArchiveFileValidate(infile, formatspecs=__file_format_dict__, verbose=False,
         catfp = BytesIO()
         catfp.write(infile)
         catfp.seek(0, 0)
-        catfp = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(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 = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(catfp, formatspecs)
         catfp.seek(0, 0)
         if(not catfp):
             return False
@@ -6036,7 +6073,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 = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(catfp, formatspecs)
         checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
@@ -6058,7 +6095,7 @@ def ArchiveFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentas
         else:
             shutil.copyfileobj(sys.stdin, catfp)
         catfp.seek(0, 0)
-        catfp = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(catfp, formatspecs)
         if(not catfp):
             return False
         catfp.seek(0, 0)
@@ -6066,13 +6103,13 @@ def ArchiveFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentas
         catfp = BytesIO()
         catfp.write(infile)
         catfp.seek(0, 0)
-        catfp = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(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 = UncompressArchiveFile(catfp, formatspecs)
+        catfp = UncompressBytesAltFP(catfp, formatspecs)
         catfp.seek(0, 0)
         if(not catfp):
             return False
@@ -6340,7 +6377,7 @@ def ArchiveFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentas
             else:
                 catfcontents.seek(0, 0)
                 if(uncompress):
-                    catfcontents = UncompressArchiveFile(
+                    catfcontents = UncompressBytesAltFP(
                         catfcontents, formatspecs)
                     catfcontents.seek(0, 0)
                     catfccs = GetFileChecksum(
@@ -6880,8 +6917,8 @@ def TarFileToArrayAlt(infile, listonly=False, contentasfile=True, checksumtype="
         fcsize = 0
         fcontents = BytesIO()
         if ftype in data_types:
-            with tarfp.extractfile(member) as fpc:
-                shutil.copyfileobj(fpc, fcontents)
+            fpc = tarfp.extractfile(member)
+            shutil.copyfileobj(fpc, fcontents)
         fcontents.seek(0, 0)
         ftypehex = format(ftype, 'x').lower()
         extrafields = len(extradata)
@@ -7018,16 +7055,16 @@ def ZipFileToArrayAlt(infile, listonly=False, contentasfile=True, checksumtype="
         zipinfo = zipfp.getinfo(member.filename)
         if(verbose):
             VerbosePrintOut(fname)
-        if(not member.is_dir()):
-            fpremode = stat.S_IFREG + 438
-        elif(member.is_dir()):
+        if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
             fpremode = stat.S_IFDIR + 511
+        else:
+            fpremode = stat.S_IFREG + 438
         flinkcount = 0
         ftype = 0
-        if(not member.is_dir()):
-            ftype = 0
-        elif(member.is_dir()):
+        if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
             ftype = 5
+        else:
+            ftype = 0
         flinkname = ""
         fbasedir = os.path.dirname(fname)
         fcurfid = curfid
@@ -7049,14 +7086,14 @@ def ZipFileToArrayAlt(infile, listonly=False, contentasfile=True, checksumtype="
         fbtime = time.mktime(member.date_time + (0, 0, -1))
         if(zipinfo.create_system == 0 or zipinfo.create_system == 10):
             fwinattributes = int(zipinfo.external_attr)
-            if(not member.is_dir()):
-                fmode = int(stat.S_IFREG + 438)
-                fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)))
-                ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)))
-            elif(member.is_dir()):
+            if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
                 fmode = int(stat.S_IFDIR + 511)
                 fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
                 ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
+            else:
+                fmode = int(stat.S_IFREG + 438)
+                fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)))
+                ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)))
         elif(zipinfo.create_system == 3):
             fwinattributes = int(0)
             try:
@@ -7069,14 +7106,14 @@ def ZipFileToArrayAlt(infile, listonly=False, contentasfile=True, checksumtype="
                 ftypemod = stat.S_IFMT(fmode)
         else:
             fwinattributes = int(0)
-            if(not member.is_dir()):
-                fmode = int(stat.S_IFREG + 438)
-                fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)))
-                ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)))
-            elif(member.is_dir()):
+            if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
                 fmode = int(stat.S_IFDIR + 511)
                 fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
                 ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
+            else:
+                fmode = int(stat.S_IFREG + 438)
+                fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)))
+                ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)))
         fcompression = ""
         fcsize = 0
         try:
@@ -7860,6 +7897,7 @@ def RePackArchiveFile(infile, outfile, compression="auto", compresswholefile=Tru
                 ilcsize = []
                 while(ilmin < ilsize):
                     cfcontents = BytesIO()
+                    fcontents.seek(0, 0)
                     shutil.copyfileobj(fcontents, cfcontents)
                     fcontents.seek(0, 0)
                     cfcontents.seek(0, 0)
@@ -7876,18 +7914,18 @@ def RePackArchiveFile(infile, outfile, compression="auto", compresswholefile=Tru
                             ilcsize.append(sys.maxsize)
                     ilmin = ilmin + 1
                 ilcmin = ilcsize.index(min(ilcsize))
-                compression = compressionlistalt[ilcmin]
+                curcompression = compressionlistalt[ilcmin]
             fcontents.seek(0, 0)
             cfcontents = BytesIO()
             shutil.copyfileobj(fcontents, cfcontents)
             cfcontents.seek(0, 0)
             cfcontents = CompressArchiveFile(
-                cfcontents, compression, compressionlevel, formatspecs)
+                cfcontents, curcompression, compressionlevel, formatspecs)
             cfcontents.seek(0, 2)
             cfsize = cfcontents.tell()
             if(ucfsize > cfsize):
                 fcsize = format(int(cfsize), 'x').lower()
-                fcompression = compression
+                fcompression = curcompression
                 fcontents.close()
                 fcontents = cfcontents
         if(followlink):
@@ -8494,7 +8532,6 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
     try:
         zipfp = zipfile.ZipFile(infile, "r", allowZip64=True)
     except FileNotFoundError:
-        print(6)
         return False
     lcfi = 0
     returnval = {}
@@ -8502,16 +8539,17 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
     if(ziptest):
         VerbosePrintOut("Bad file found!")
     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)
-            if(not member.is_dir()):
-                fmode = int(stat.S_IFREG + 438)
-                fchmode = int(stat.S_IMODE(fmode))
-                ftypemod = int(stat.S_IFMT(fmode))
-            elif(member.is_dir()):
+            if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
                 fmode = int(stat.S_IFDIR + 511)
                 fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
                 ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
+            else:
+                fmode = int(stat.S_IFREG + 438)
+                fchmode = int(stat.S_IMODE(fmode))
+                ftypemod = int(stat.S_IFMT(fmode))
         elif(zipinfo.create_system == 3):
             fwinattributes = int(0)
             try:
@@ -8524,14 +8562,14 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
                 ftypemod = stat.S_IFMT(fmode)
         else:
             fwinattributes = int(0)
-            if(not member.is_dir()):
-                fmode = int(stat.S_IFREG + 438)
-                fchmode = int(stat.S_IMODE(fmode))
-                ftypemod = int(stat.S_IFMT(fmode))
-            elif(member.is_dir()):
+            if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
                 fmode = int(stat.S_IFDIR + 511)
                 fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
                 ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
+            else:
+                fmode = int(stat.S_IFREG + 438)
+                fchmode = int(stat.S_IMODE(fmode))
+                ftypemod = int(stat.S_IFMT(fmode))
         returnval.update({lcfi: member.filename})
         if(not verbose):
             VerbosePrintOut(member.filename)
@@ -8542,12 +8580,12 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
             for fmodval in str(oct(fmode))[-3:]:
                 permissionstr = permissionstr + \
                     permissions['access'].get(fmodval, '---')
-            if(not member.is_dir()):
-                ftype = 0
-                permissionstr = "-" + permissionstr
-            elif(member.is_dir()):
+            if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
                 ftype = 5
                 permissionstr = "d" + permissionstr
+            else:
+                ftype = 0
+                permissionstr = "-" + permissionstr
             printfname = member.filename
             try:
                 fuid = int(os.getuid())
@@ -9406,7 +9444,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 = UncompressArchiveFile(fp, formatspecs)
+    fp = UncompressBytesAltFP(fp, formatspecs)
     fp.seek(0, 0)
     if(not fp):
         return False
@@ -9432,7 +9470,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 = UncompressArchiveFile(fp, formatspecs)
+    fp = UncompressBytesAltFP(fp, formatspecs)
     fp.seek(0, 0)
     if(not fp):
         return False