PyCatFile 0.20.8__py3-none-any.whl → 0.21.2__py3-none-any.whl

pycatfile.py

@@ -14,7 +14,7 @@
     Copyright 2018-2024 Game Maker 2k - http://intdb.sourceforge.net/
     Copyright 2018-2024 Kazuki Przyborowski - https://github.com/KazukiPrzyborowski
 
-    $FileInfo: pycatfile.py - Last Update: 9/16/2025 Ver. 0.20.8 RC 1 - Author: cooldude2k $
+    $FileInfo: pycatfile.py - Last Update: 8/24/2025 Ver. 0.21.2 RC 1 - Author: cooldude2k $
 '''
 
 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
@@ -391,12 +391,12 @@ __file_format_extension__ = __file_format_multi_dict__[__file_format_default__][
 __file_format_dict__ = __file_format_multi_dict__[__file_format_default__]
 __project__ = __program_name__
 __project_url__ = "https://github.com/GameMaker2k/PyCatFile"
-__version_info__ = (0, 20, 8, "RC 1", 1)
-__version_date_info__ = (2025, 9, 16, "RC 1", 1)
+__version_info__ = (0, 21, 2, "RC 1", 1)
+__version_date_info__ = (2025, 9, 24, "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: a69bd62016afabfda33086a3b227152aaf9e7521 $"
+__revision_id__ = "$Id: aa79a32fe42d54c127f8f31a24dc7b2be0fb1153 $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -1959,15 +1959,15 @@ def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipcheck
         HeaderOut = ReadFileHeaderDataWoSize(fp, delimiter)
     if(len(HeaderOut) == 0):
         return False
-    if(re.findall("^[.|/]", HeaderOut[3])):
-        fname = HeaderOut[3]
+    if(re.findall("^[.|/]", HeaderOut[5])):
+        fname = HeaderOut[5]
     else:
-        fname = "./"+HeaderOut[3]
+        fname = "./"+HeaderOut[5]
     fcs = HeaderOut[-2].lower()
     fccs = HeaderOut[-1].lower()
-    fsize = int(HeaderOut[5], 16)
-    fcompression = HeaderOut[12]
-    fcsize = int(HeaderOut[13], 16)
+    fsize = int(HeaderOut[7], 16)
+    fcompression = HeaderOut[14]
+    fcsize = int(HeaderOut[15], 16)
     fseeknextfile = HeaderOut[26]
     fjsontype = HeaderOut[27]
     fjsonlen = int(HeaderOut[28], 16)
@@ -2020,6 +2020,7 @@ def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipcheck
     fcontents.seek(0, 0)
     newfccs = GetFileChecksum(
         fcontents.read(), HeaderOut[-3].lower(), False, formatspecs)
+    fcontents.seek(0, 0)
     if(fccs != newfccs and not skipchecksum and not listonly):
         VerbosePrintOut("File Content Checksum Error with file " +
                         fname + " at offset " + str(fcontentstart))
@@ -2032,7 +2033,7 @@ def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipcheck
         if(uncompress):
             cfcontents = UncompressFileAlt(fcontents, formatspecs)
             cfcontents.seek(0, 0)
-            cfcontents.seek(0, 0)
+            fcontents = BytesIO()
             shutil.copyfileobj(cfcontents, fcontents)
             cfcontents.close()
             fcontents.seek(0, 0)
@@ -2124,6 +2125,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
                 fextrafieldslist = json.loads(fextrafieldslist[0])
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 pass
+    fjstart = fp.tell()
     if(fjsontype=="json"):
         fjsoncontent = {}
         fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
@@ -2151,11 +2153,11 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
         fjsoncontent = ReadFileHeaderData(flisttmp, fjsonlen, delimiter)
         flisttmp.close()
         fjsonrawcontent = fjsoncontent
-        if(outfjsonlen==1):
+        if(fjsonlen==1):
             try:
                 fjsonrawcontent = base64.b64decode(fjsoncontent[0]).decode("UTF-8")
                 fjsoncontent = json.loads(base64.b64decode(fjsoncontent[0]).decode("UTF-8"))
-                outfjsonlen = len(fjsoncontent)
+                fjsonlen = len(fjsoncontent)
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 try:
                     fjsonrawcontent = fjsoncontent[0]
@@ -2163,6 +2165,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
                 except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                     pass
     fp.seek(len(delimiter), 1)
+    fjend = fp.tell() - 1
     jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs)
     if(jsonfcs != fjsonchecksum and not skipchecksum):
         VerbosePrintOut("File JSON Data Checksum Error with file " +
@@ -2197,6 +2200,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
     fcontents.seek(0, 0)
     newfccs = GetFileChecksum(
         fcontents.read(), HeaderOut[-3].lower(), False, formatspecs)
+    fcontents.seek(0, 0)
     if(fccs != newfccs and not skipchecksum and not listonly):
         VerbosePrintOut("File Content Checksum Error with file " +
                         fname + " at offset " + str(fcontentstart))
@@ -2238,7 +2242,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
     if(not contentasfile):
         fcontents = fcontents.read()
     outlist = {'fheadersize': fheadsize, 'fhstart': fheaderstart, 'fhend': fhend, 'ftype': ftype, 'fencoding': fencoding, 'fcencoding': fcencoding, 'fname': fname, 'fbasedir': fbasedir, 'flinkname': flinkname, 'fsize': fsize, 'fatime': fatime, 'fmtime': fmtime, 'fctime': fctime, 'fbtime': fbtime, 'fmode': fmode, 'fchmode': fchmode, 'ftypemod': ftypemod, 'fwinattributes': fwinattributes, 'fcompression': fcompression, 'fcsize': fcsize, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount,
-               'fdev': fdev, 'fminor': fdev_minor, 'fmajor': fdev_major, 'fseeknextfile': fseeknextfile, 'fheaderchecksumtype': HeaderOut[-4], 'fjsonchecksumtype': outfjsonchecksumtype, 'fcontentchecksumtype': HeaderOut[-3], 'fnumfields': fnumfields + 2, 'frawheader': HeaderOut, 'fextrafields': fextrafields, 'fextrafieldsize': fextrasize, 'fextradata': fextrafieldslist, 'fjsontype': fjsontype, 'fjsonlen': fjsonlen, 'fjsonsize': fjsonsize, 'fjsonrawdata': fjsonrawcontent, 'fjsondata': fjsoncontent, 'fjstart': outfjstart, 'fjend': outfjend, 'fheaderchecksum': fcs, 'fjsonchecksum': outfjsonchecksum, 'fcontentchecksum': fccs, 'fhascontents': pyhascontents, 'fcontentstart': fcontentstart, 'fcontentend': fcontentend, 'fcontentasfile': contentasfile, 'fcontents': fcontents}
+               'fdev': fdev, 'fminor': fdev_minor, 'fmajor': fdev_major, 'fseeknextfile': fseeknextfile, 'fheaderchecksumtype': HeaderOut[-4], 'fjsonchecksumtype': fjsonchecksumtype, 'fcontentchecksumtype': HeaderOut[-3], 'fnumfields': fnumfields + 2, 'frawheader': HeaderOut, 'fextrafields': fextrafields, 'fextrafieldsize': fextrasize, 'fextradata': fextrafieldslist, 'fjsontype': fjsontype, 'fjsonlen': fjsonlen, 'fjsonsize': fjsonsize, 'fjsonrawdata': fjsonrawcontent, 'fjsondata': fjsoncontent, 'fjstart': fjstart, 'fjend': fjend, 'fheaderchecksum': fcs, 'fjsonchecksum': fjsonchecksum, 'fcontentchecksum': fccs, 'fhascontents': pyhascontents, 'fcontentstart': fcontentstart, 'fcontentend': fcontentend, 'fcontentasfile': contentasfile, 'fcontents': fcontents}
     return outlist
 
 
@@ -2335,11 +2339,11 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
         fjsoncontent = ReadFileHeaderData(flisttmp, fjsonlen, delimiter)
         flisttmp.close()
         fjsonrawcontent = fjsoncontent
-        if(fextrafields==1):
+        if(fjsonlen==1):
             try:
                 fjsonrawcontent = base64.b64decode(fjsoncontent[0]).decode("UTF-8")
                 fjsoncontent = json.loads(base64.b64decode(fjsoncontent[0]).decode("UTF-8"))
-                fextrafields = len(fjsoncontent)
+                fjsonlen = len(fjsoncontent)
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 try:
                     fjsonrawcontent = fjsoncontent[0]
@@ -2549,11 +2553,11 @@ def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, c
     formversions = re.search('(.*?)(\\d+)', formstring).groups()
     fcompresstype = ""
     outlist = {'fnumfiles': fnumfiles, 'fformat': formversions[0], 'fcompression': fcompresstype, 'fencoding': fhencoding, 'fversion': formversions[1], 'fostype': fostype, 'fheadersize': fheadsize, 'fsize': CatSizeEnd, 'fnumfields': fnumfields + 2, 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'frawheader': [formstring] + inheader, 'fextrafields': fnumextrafields, 'fextrafieldsize': fnumextrafieldsize, 'fextradata': fextrafieldslist, 'ffilelist': []}
-    if(seekstart < 0 and seekstart > fnumfiles):
+    if (seekstart < 0) or (seekstart > fnumfiles):
         seekstart = 0
-    if(seekend == 0 or seekend > fnumfiles and seekend < seekstart):
+    if (seekend == 0) or (seekend > fnumfiles) or (seekend < seekstart):
         seekend = fnumfiles
-    elif(seekend < 0 and abs(seekend) <= fnumfiles and abs(seekend) >= seekstart):
+    elif (seekend < 0) and (abs(seekend) <= fnumfiles) and (abs(seekend) >= seekstart):
         seekend = fnumfiles - abs(seekend)
     if(seekstart > 0):
         il = 0
@@ -2564,14 +2568,18 @@ def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, c
             if(len(preheaderdata) == 0):
                 break
             prefsize = int(preheaderdata[5], 16)
+            if(re.findall("^[.|/]", preheaderdata[5])):
+                prefname = preheaderdata[5]
+            else:
+                prefname = "./"+preheaderdata[5]
             prefseeknextfile = preheaderdata[26]
             prefjsonlen = int(preheaderdata[28], 16)
             prefjsonsize = int(preheaderdata[29], 16)
             prefjsonchecksumtype = preheaderdata[30]
             prefjsonchecksum = preheaderdata[31]
-            prefprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
+            prejsoncontent = fp.read(prefjsonsize).decode("UTF-8")
             fp.seek(len(delimiter), 1)
-            prejsonfcs = GetFileChecksum(fprejsoncontent, prefjsonchecksumtype, True, formatspecs)
+            prejsonfcs = GetFileChecksum(prejsoncontent, prefjsonchecksumtype, True, formatspecs)
             if(prejsonfcs != prefjsonchecksum and not skipchecksum):
                 VerbosePrintOut("File JSON Data Checksum Error with file " +
                                 prefname + " at offset " + str(prefhstart))
@@ -2581,7 +2589,7 @@ def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, c
                 preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs)
             prefcs = preheaderdata[-2]
             if(prefcs != prenewfcs and not skipchecksum):
-                VVerbosePrintOut("File Header Checksum Error with file " +
+                VerbosePrintOut("File Header Checksum Error with file " +
                                  prefname + " at offset " + str(prefhstart))
                 VerbosePrintOut("'" + prefcs + "' != " +
                                 "'" + prenewfcs + "'")
@@ -2704,11 +2712,11 @@ def ReadFileDataWithContentToList(fp, seekstart=0, seekend=0, listonly=False, co
         return False
     formversions = re.search('(.*?)(\\d+)', formstring).groups()
     outlist = []
-    if(seekstart < 0 and seekstart > fnumfiles):
+    if (seekstart < 0) or (seekstart > fnumfiles):
         seekstart = 0
-    if(seekend == 0 or seekend > fnumfiles and seekend < seekstart):
+    if (seekend == 0) or (seekend > fnumfiles) or (seekend < seekstart):
         seekend = fnumfiles
-    elif(seekend < 0 and abs(seekend) <= fnumfiles and abs(seekend) >= seekstart):
+    elif (seekend < 0) and (abs(seekend) <= fnumfiles) and (abs(seekend) >= seekstart):
         seekend = fnumfiles - abs(seekend)
     if(seekstart > 0):
         il = 0
@@ -2723,16 +2731,20 @@ def ReadFileDataWithContentToList(fp, seekstart=0, seekend=0, listonly=False, co
             if(len(preheaderdata) == 0):
                 break
             prefsize = int(preheaderdata[5], 16)
-            prefcompression = preheaderdata[12]
-            prefcsize = int(preheaderdata[13], 16)
-            prefseeknextfile = HeaderOut[26]
+            if(re.findall("^[.|/]", preheaderdata[5])):
+                prefname = preheaderdata[5]
+            else:
+                prefname = "./"+preheaderdata[5]
+            prefcompression = preheaderdata[14]
+            prefcsize = int(preheaderdata[15], 16)
+            prefseeknextfile = preheaderdata[26]
             prefjsonlen = int(preheaderdata[28], 16)
             prefjsonsize = int(preheaderdata[29], 16)
             prefjsonchecksumtype = preheaderdata[30]
             prefjsonchecksum = preheaderdata[31]
             prefprejsoncontent = fp.read(prefjsonsize).decode("UTF-8")
             fp.seek(len(delimiter), 1)
-            prejsonfcs = GetFileChecksum(fprejsoncontent, prefjsonchecksumtype, True, formatspecs)
+            prejsonfcs = GetFileChecksum(prefprejsoncontent, prefjsonchecksumtype, True, formatspecs)
             if(prejsonfcs != prefjsonchecksum and not skipchecksum):
                 VerbosePrintOut("File JSON Data Checksum Error with file " +
                                 prefname + " at offset " + str(prefhstart))
@@ -2819,13 +2831,13 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
         fp = UncompressFileAlt(fp, formatspecs)
         checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-            return ZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return ZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-            return RarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return RarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-            return SevenZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return SevenZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
@@ -2935,13 +2947,13 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-            return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-            return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-            return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
@@ -2980,7 +2992,7 @@ def ReadInMultipleFileWithContentToArray(infile, fmttype="auto", seekstart=0, se
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        curretfile = outretval.update({curfname: ReadInFileWithContentToArray(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)})
+        outretval[curfname] = ReadInFileWithContentToArray(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
     return outretval
 
 def ReadInMultipleFilesWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
@@ -3007,13 +3019,13 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
         fp = UncompressFileAlt(fp, formatspecs)
         checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-            return ZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return ZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-            return RarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return RarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-            return SevenZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return SevenZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
@@ -3123,13 +3135,13 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-            return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-            return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-            return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
@@ -3168,7 +3180,7 @@ def ReadInMultipleFileWithContentToList(infile, fmttype="auto", seekstart=0, see
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        curretfile = outretval.update({curfname: ReadInFileWithContentToList(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)})
+        curretfile[curfname] = ReadInFileWithContentToList(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
     return outretval
 
 def ReadInMultipleFilesWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
@@ -3213,7 +3225,7 @@ def AppendFileHeader(fp, numfiles, fencoding, extradata=[], checksumtype="crc32"
     tmpoutlist = []
     tmpoutlist.append(extrasizelen)
     tmpoutlist.append(extrafields)
-    fnumfiles = format(int(numfiles), 'x').lower()
+    fnumfiles = format(numfiles, 'x').lower()
     tmpoutlen = 3 + len(tmpoutlist) + len(extradata) + 2
     tmpoutlenhex = format(tmpoutlen, 'x').lower()
     fnumfilesa = AppendNullBytes(
@@ -3267,11 +3279,11 @@ def MakeEmptyFilePointer(fp, fmttype=__file_format_default__, checksumtype="crc3
     return fp
 
 
-def MakeEmptyCatFilePointer(fp, fmttype=__file_format_default__, checksumtype="crc32", formatspecs=__file_format_multi_dict__):
+def MakeEmptyArchiveFilePointer(fp, fmttype=__file_format_default__, checksumtype="crc32", formatspecs=__file_format_multi_dict__):
     return MakeEmptyFilePointer(fp, fmttype, checksumtype, formatspecs)
 
 
-def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", formatspecs=__file_format_multi_dict__, returnfp=False):
+def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype="crc32", formatspecs=__file_format_multi_dict__, returnfp=False):
     if(IsNestedDict(formatspecs) and fmttype=="auto" and 
         (outfile != "-" and outfile is not None and not hasattr(outfile, "read") and not hasattr(outfile, "write"))):
         get_in_ext = os.path.splitext(outfile)
@@ -3315,7 +3327,7 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
     AppendFileHeader(fp, 0, "UTF-8", [], checksumtype, formatspecs)
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -3339,7 +3351,7 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
         return outvar
     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -3350,8 +3362,8 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
         return True
 
 
-def MakeEmptyCatFile(outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", formatspecs=__file_format_dict__, returnfp=False):
-    return MakeEmptyFile(outfile, compression, compresswholefile, compressionlevel, checksumtype, formatspecs, returnfp)
+def MakeEmptyArchiveFile(outfile, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype="crc32", formatspecs=__file_format_dict__, returnfp=False):
+    return MakeEmptyFile(outfile, "auto", compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, returnfp)
 
 
 def AppendFileHeaderWithContent(fp, filevalues=[], extradata=[], jsondata={}, filecontent="", checksumtype=["crc32", "crc32", "crc32"], formatspecs=__file_format_dict__):
@@ -3450,6 +3462,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
     if(verbose):
         logging.basicConfig(format="%(message)s",
                             stream=sys.stdout, level=logging.DEBUG)
+    infilelist = []
     if(infiles == "-"):
         for line in sys.stdin:
             infilelist.append(line.strip())
@@ -3490,7 +3503,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
     inodetoforminode = {}
     numfiles = int(len(GetDirList))
     fnumfiles = format(numfiles, 'x').lower()
-    AppendFileHeader(fp, fnumfiles, "UTF-8", [], checksumtype[0], formatspecs)
+    AppendFileHeader(fp, numfiles, "UTF-8", [], checksumtype[0], formatspecs)
     FullSizeFilesAlt = 0
     for curfname in GetDirList:
         fencoding = "UTF-8"
@@ -3588,7 +3601,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
         elif ftype in data_types:
             fsize = format(int(fstatinfo.st_size), 'x').lower()
         else:
-            fsize = format(int(fstatinfo.st_size)).lower()
+            fsize = format(int(fstatinfo.st_size), 'x').lower()
         fatime = format(int(fstatinfo.st_atime), 'x').lower()
         fmtime = format(int(fstatinfo.st_mtime), 'x').lower()
         fctime = format(int(fstatinfo.st_ctime), 'x').lower()
@@ -3636,11 +3649,14 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
         fcontents = BytesIO()
         chunk_size = 1024
         fcencoding = "UTF-8"
-        if ftype in data_types:
+        curcompression = "none"
+        if not followlink and ftype in data_types:
             with open(fname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, False)
-                if(not compresswholefile):
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -3655,16 +3671,13 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
                             cfcontents = CompressOpenFileAlt(
-                                cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                                cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, 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)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -3673,7 +3686,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, curcompression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
@@ -3681,13 +3694,16 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                         fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
-        if(followlink and (ftype == 1 or ftype == 2)):
+        elif followlink and (ftype == 1 or ftype == 2):
             if(not os.path.exists(flinkname)):
                 return False
             flstatinfo = os.stat(flinkname)
             with open(flinkname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                if(not compresswholefile):
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
+                fcencoding = GetFileEncoding(fcontents, False)
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -3702,16 +3718,13 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
                             cfcontents = CompressOpenFileAlt(
-                                cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                                cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, 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)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -3720,7 +3733,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, curcompression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
@@ -3762,7 +3775,7 @@ def AppendListsWithContent(inlist, fp, dirlistfromtxt=False, filevalues=[], extr
     inodetoforminode = {}
     numfiles = int(len(GetDirList))
     fnumfiles = format(numfiles, 'x').lower()
-    AppendFileHeader(fp, fnumfiles, "UTF-8", [], checksumtype[0], formatspecs)
+    AppendFileHeader(fp, numfiles, "UTF-8", [], checksumtype[0], formatspecs)
     for curfname in GetDirList:
         ftype = format(curfname[0], 'x').lower()
         fencoding = curfname[1]
@@ -3864,7 +3877,7 @@ def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, fmtt
                                    compresswholefile, compressionlevel, compressionuselist, followlink, checksumtype, formatspecs, verbose)
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -3888,7 +3901,7 @@ def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, fmtt
         return outvar
     elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -3944,7 +3957,7 @@ def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, fmtty
                                    compresswholefile, compressionlevel, followlink, checksumtype, formatspecs, verbose)
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -3968,7 +3981,7 @@ def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, fmtty
         return outvar
     elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -4659,13 +4672,13 @@ def UncompressBytesAltFP(fp, formatspecs=__file_format_multi_dict__):
     return filefp
 
 
-def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, formatspecs=__file_format_dict__):
+def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, compressionuselist=compressionlistalt, formatspecs=__file_format_dict__):
     if(not hasattr(fp, "read")):
         return False
     fp.seek(0, 0)
     if(not compression or compression == formatspecs['format_magic']):
         compression = "auto"
-    if(compression not in compressionlist and compression is None):
+    if(compression not in compressionuselist and compression is None):
         compression = "auto"
     if(compression == "gzip" and compression in compressionsupport):
         bytesfp = BytesIO()
@@ -4884,7 +4897,7 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         outfile = RemoveWindowsPath(outfile)
     if(not compression or compression == formatspecs['format_magic']):
         compression = "auto"
-    if(compression not in compressionlist and compression is None):
+    if(compression not in compressionuselist and compression is None):
         compression = "auto"
     if(verbose):
         logging.basicConfig(format="%(message)s",
@@ -5051,7 +5064,7 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         elif ftype in data_types:
             fsize = format(int(fstatinfo.st_size), 'x').lower()
         else:
-            fsize = format(int(fstatinfo.st_size)).lower()
+            fsize = format(int(fstatinfo.st_size), 'x').lower()
         fatime = format(int(fstatinfo.st_atime), 'x').lower()
         fmtime = format(int(fstatinfo.st_mtime), 'x').lower()
         fctime = format(int(fstatinfo.st_ctime), 'x').lower()
@@ -5098,11 +5111,14 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         fcsize = format(int(0), 'x').lower()
         fcontents = BytesIO()
         fcencoding = "UTF-8"
-        if ftype in data_types:
+        curcompression = "none"
+        if not followlink and ftype in data_types:
             with open(fname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, False)
-                if(not compresswholefile):
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -5117,16 +5133,13 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
                             cfcontents = CompressOpenFileAlt(
-                                cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                                cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, 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)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -5135,7 +5148,7 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, curcompression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
@@ -5143,15 +5156,16 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
-        if(fcompression == "none"):
-            fcompression = ""
-        if(followlink and (ftype == 1 or ftype == 2)):
+        elif followlink and (ftype == 1 or ftype == 2):
             if(not os.path.exists(flinkname)):
                 return False
             flstatinfo = os.stat(flinkname)
             with open(flinkname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                if(not compresswholefile):
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
+                fcencoding = GetFileEncoding(fcontents, False)
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -5166,16 +5180,13 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
                             cfcontents = CompressOpenFileAlt(
-                                cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                                cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, 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)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -5184,7 +5195,7 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, curcompression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
@@ -5192,6 +5203,8 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
+        if(fcompression == "none"):
+            fcompression = ""
         fcontents.seek(0, 0)
         ftypehex = format(ftype, 'x').lower()
         tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
@@ -5207,7 +5220,7 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
             return False
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -5231,7 +5244,7 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         return outvar
     elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -5269,7 +5282,7 @@ def PackCatFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         outfile = RemoveWindowsPath(outfile)
     if(not compression or compression == formatspecs['format_magic']):
         compression = "auto"
-    if(compression not in compressionlist and compression is None):
+    if(compression not in compressionuselist and compression is None):
         compression = "auto"
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
@@ -5344,7 +5357,7 @@ def PackCatFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                 if 'zstandard' in sys.modules:
                     infile = ZstdFile(fileobj=infile, mode="rb")
                 elif 'pyzstd' in sys.modules:
-                    fp = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(fileobj=infile, mode="r")
@@ -5356,7 +5369,7 @@ def PackCatFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                 if 'zstandard' in sys.modules:
                     infile = ZstdFile(fileobj=infile, mode="rb")
                 elif 'pyzstd' in sys.modules:
-                    fp = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(infile, "r")
@@ -5445,11 +5458,15 @@ def PackCatFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         fcsize = format(int(0), 'x').lower()
         fcontents = BytesIO()
         fcencoding = "UTF-8"
+        curcompression = "none"
         if ftype in data_types:
             fpc = tarfp.extractfile(member)
+            fpc.close()
             shutil.copyfileobj(fpc, fcontents)
+            typechecktest = CheckCompressionType(fcontents, closefp=False)
+            fcontents.seek(0, 0)
             fcencoding = GetFileEncoding(fcontents, False)
-            if(not compresswholefile):
+            if(typechecktest is False and not compresswholefile):
                 fcontents.seek(0, 2)
                 ucfsize = fcontents.tell()
                 fcontents.seek(0, 0)
@@ -5464,16 +5481,13 @@ def PackCatFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                         fcontents.seek(0, 0)
                         cfcontents.seek(0, 0)
                         cfcontents = CompressOpenFileAlt(
-                            cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                            cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, 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)
+                            ilcsize.append(float("inf"))
                         ilmin = ilmin + 1
                     ilcmin = ilcsize.index(min(ilcsize))
                     curcompression = compressionuselist[ilcmin]
@@ -5482,7 +5496,7 @@ def PackCatFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                 shutil.copyfileobj(fcontents, cfcontents)
                 cfcontents.seek(0, 0)
                 cfcontents = CompressOpenFileAlt(
-                    cfcontents, curcompression, compressionlevel, formatspecs)
+                    cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                 cfcontents.seek(0, 2)
                 cfsize = cfcontents.tell()
                 if(ucfsize > cfsize):
@@ -5507,7 +5521,7 @@ def PackCatFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
             return False
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -5531,7 +5545,7 @@ def PackCatFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         return outvar
     elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -5565,7 +5579,7 @@ def PackCatFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
         outfile = RemoveWindowsPath(outfile)
     if(not compression or compression == formatspecs['format_magic']):
         compression = "auto"
-    if(compression not in compressionlist and compression is None):
+    if(compression not in compressionuselist and compression is None):
         compression = "auto"
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
@@ -5743,10 +5757,13 @@ def PackCatFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
             fgname = ""
         fcontents = BytesIO()
         fcencoding = "UTF-8"
-        if(ftype == 0):
+        curcompression = "none"
+        if ftype == 0:
             fcontents.write(zipfp.read(member.filename))
+            typechecktest = CheckCompressionType(fcontents, closefp=False)
+            fcontents.seek(0, 0)
             fcencoding = GetFileEncoding(fcontents, False)
-            if(not compresswholefile):
+            if(typechecktest is False and not compresswholefile):
                 fcontents.seek(0, 2)
                 ucfsize = fcontents.tell()
                 fcontents.seek(0, 0)
@@ -5761,7 +5778,7 @@ def PackCatFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
                         fcontents.seek(0, 0)
                         cfcontents.seek(0, 0)
                         cfcontents = CompressOpenFileAlt(
-                            cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                            cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, formatspecs)
                         cfcontents.seek(0, 2)
                         ilcsize.append(cfcontents.tell())
                         cfcontents.close()
@@ -5773,7 +5790,7 @@ def PackCatFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
                 shutil.copyfileobj(fcontents, cfcontents)
                 cfcontents.seek(0, 0)
                 cfcontents = CompressOpenFileAlt(
-                    cfcontents, curcompression, compressionlevel, formatspecs)
+                    cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                 cfcontents.seek(0, 2)
                 cfsize = cfcontents.tell()
                 if(ucfsize > cfsize):
@@ -5798,7 +5815,7 @@ def PackCatFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
             return False
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -5822,7 +5839,7 @@ def PackCatFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
         return outvar
     elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -5861,7 +5878,7 @@ if(rarfile_support):
             outfile = RemoveWindowsPath(outfile)
         if(not compression or compression == formatspecs['format_magic']):
             compression = "auto"
-        if(compression not in compressionlist and compression is None):
+        if(compression not in compressionuselist and compression is None):
             compression = "auto"
         if(verbose):
             logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
@@ -6057,10 +6074,13 @@ if(rarfile_support):
                 fgname = ""
             fcontents = BytesIO()
             fcencoding = "UTF-8"
-            if(ftype == 0):
+            curcompression = "none"
+            if ftype == 0:
                 fcontents.write(rarfp.read(member.filename))
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, False)
-                if(not compresswholefile):
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -6075,16 +6095,13 @@ if(rarfile_support):
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
                             cfcontents = CompressOpenFileAlt(
-                                cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                                cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, 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)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -6093,12 +6110,12 @@ if(rarfile_support):
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, curcompression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, compressionuselist, 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"):
@@ -6118,7 +6135,7 @@ if(rarfile_support):
                 return False
         if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = CompressOpenFileAlt(
-                fp, compression, compressionlevel, formatspecs)
+                fp, compression, compressionlevel, compressionuselist, formatspecs)
             try:
                 fp.flush()
                 if(hasattr(os, "sync")):
@@ -6142,7 +6159,7 @@ if(rarfile_support):
             return outvar
         elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
             fp = CompressOpenFileAlt(
-                fp, compression, compressionlevel, formatspecs)
+                fp, compression, compressionlevel, compressionuselist, formatspecs)
             fp.seek(0, 0)
             upload_file_to_internet_file(fp, outfile)
         if(returnfp):
@@ -6181,7 +6198,7 @@ if(py7zr_support):
             outfile = RemoveWindowsPath(outfile)
         if(not compression or compression == formatspecs['format_magic']):
             compression = "auto"
-        if(compression not in compressionlist and compression is None):
+        if(compression not in compressionuselist and compression is None):
             compression = "auto"
         if(verbose):
             logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
@@ -6308,12 +6325,16 @@ if(py7zr_support):
                 fgname = ""
             fcontents = BytesIO()
             fcencoding = "UTF-8"
-            if(ftype == 0):
+            curcompression = "none"
+            if ftype == 0:
                 fcontents.write(file_content[member.filename].read())
-                fcencoding = GetFileEncoding(fcontents, False)
                 fsize = format(fcontents.tell(), 'x').lower()
+                fcontents.seek(0, 0)
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
+                fcencoding = GetFileEncoding(fcontents, False)
                 file_content[member.filename].close()
-                if(not compresswholefile):
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -6328,16 +6349,13 @@ if(py7zr_support):
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
                             cfcontents = CompressOpenFileAlt(
-                                cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                                cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, 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)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -6346,7 +6364,7 @@ if(py7zr_support):
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, curcompression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
@@ -6371,7 +6389,7 @@ if(py7zr_support):
                 return False
         if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = CompressOpenFileAlt(
-                fp, compression, compressionlevel, formatspecs)
+                fp, compression, compressionlevel, compressionuselist, formatspecs)
             try:
                 fp.flush()
                 if(hasattr(os, "sync")):
@@ -6395,7 +6413,7 @@ if(py7zr_support):
             return outvar
         elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
             fp = CompressOpenFileAlt(
-                fp, compression, compressionlevel, formatspecs)
+                fp, compression, compressionlevel, compressionuselist, formatspecs)
             fp.seek(0, 0)
             upload_file_to_internet_file(fp, outfile)
         if(returnfp):
@@ -7592,11 +7610,11 @@ def CatFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
     if(fcompresstype==formatspecs['format_magic']):
         fcompresstype = ""
     outlist = {'fnumfiles': fnumfiles, 'fformat': formversions[0], 'fcompression': fcompresstype, 'fencoding': fhencoding, 'fversion': formversions[1], 'fostype': fostype, 'fheadersize': fheadsize, 'fsize': CatSizeEnd, 'fnumfields': fnumfields + 2, 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'frawheader': [formstring] + inheader, 'fextrafields': fnumextrafields, 'fextrafieldsize': fnumextrafieldsize, 'fextradata': fextrafieldslist, 'ffilelist': []}
-    if(seekstart < 0 and seekstart > fnumfiles):
+    if (seekstart < 0) or (seekstart > fnumfiles):
         seekstart = 0
-    if(seekend == 0 or seekend > fnumfiles and seekend < seekstart):
+    if (seekend == 0) or (seekend > fnumfiles) or (seekend < seekstart):
         seekend = fnumfiles
-    elif(seekend < 0 and abs(seekend) <= fnumfiles and abs(seekend) >= seekstart):
+    elif (seekend < 0) and (abs(seekend) <= fnumfiles) and (abs(seekend) >= seekstart):
         seekend = fnumfiles - abs(seekend)
     if(seekstart > 0):
         il = 0
@@ -7887,7 +7905,7 @@ def MultipleCatFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listo
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        curretfile = outretval.update({curfname: CatFileToArray(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)})
+        curretfile[curfname] = ArchiveFileToArray(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
     return outretval
 
 def MultipleCatFilesToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
@@ -8071,7 +8089,7 @@ def RePackCatFile(infile, outfile, fmttype="auto", compression="auto", compressw
         outfile = RemoveWindowsPath(outfile)
     if(not compression or compression == formatspecs['format_magic']):
         compression = "auto"
-    if(compression not in compressionlist and compression is None):
+    if(compression not in compressionuselist and compression is None):
         compression = "auto"
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
@@ -8178,10 +8196,13 @@ def RePackCatFile(infile, outfile, fmttype="auto", compression="auto", compressw
         fcontents = listarchivefiles['ffilelist'][reallcfi]['fcontents']
         if(not listarchivefiles['ffilelist'][reallcfi]['fcontentasfile']):
             fcontents = BytesIO(fcontents)
+        typechecktest = CheckCompressionType(fcontents, closefp=False)
+        fcontents.seek(0, 0)
         fcencoding = GetFileEncoding(fcontents, False)
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
-        if(not compresswholefile):
+        curcompression = "none"
+        if typechecktest is False and not compresswholefile:
             fcontents.seek(0, 2)
             ucfsize = fcontents.tell()
             fcontents.seek(0, 0)
@@ -8196,16 +8217,13 @@ def RePackCatFile(infile, outfile, fmttype="auto", compression="auto", compressw
                     fcontents.seek(0, 0)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                        cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, 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)
+                        ilcsize.append(float("inf"))
                     ilmin = ilmin + 1
                 ilcmin = ilcsize.index(min(ilcsize))
                 curcompression = compressionuselist[ilcmin]
@@ -8214,7 +8232,7 @@ def RePackCatFile(infile, outfile, fmttype="auto", compression="auto", compressw
             shutil.copyfileobj(fcontents, cfcontents)
             cfcontents.seek(0, 0)
             cfcontents = CompressOpenFileAlt(
-                cfcontents, curcompression, compressionlevel, formatspecs)
+                cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
             cfcontents.seek(0, 2)
             cfsize = cfcontents.tell()
             if(ucfsize > cfsize):
@@ -8222,7 +8240,7 @@ def RePackCatFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 fcompression = curcompression
                 fcontents.close()
                 fcontents = cfcontents
-        if(followlink):
+        if followlink:
             if(listarchivefiles['ffilelist'][reallcfi]['ftype'] == 1 or listarchivefiles['ffilelist'][reallcfi]['ftype'] == 2):
                 getflinkpath = listarchivefiles['ffilelist'][reallcfi]['flinkname']
                 flinkid = prelistarchivefiles['filetoid'][getflinkpath]
@@ -8294,7 +8312,7 @@ def RePackCatFile(infile, outfile, fmttype="auto", compression="auto", compressw
             return False
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -8318,7 +8336,7 @@ def RePackCatFile(infile, outfile, fmttype="auto", compression="auto", compressw
         return outvar
     elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -8631,7 +8649,7 @@ def CatFileListFiles(infile, fmttype="auto", seekstart=0, seekend=0, skipchecksu
     else:
         if(infile != "-" and not hasattr(infile, "read") and not hasattr(infile, "write") and not (sys.version_info[0] >= 3 and isinstance(infile, bytes))):
             infile = RemoveWindowsPath(infile)
-        listarchivefiles = ArchiveFileToArray(infile, fmttype, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
+        listarchivefiles = CatFileToArray(infile, fmttype, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
     if(not listarchivefiles):
         return False
     lenlist = len(listarchivefiles['ffilelist'])
@@ -8727,7 +8745,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
                 if 'zstandard' in sys.modules:
                     infile = ZstdFile(fileobj=infile, mode="rb")
                 elif 'pyzstd' in sys.modules:
-                    fp = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(fileobj=infile, mode="r")
@@ -8739,7 +8757,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
                 if 'zstandard' in sys.modules:
                     infile = ZstdFile(fileobj=infile, mode="rb")
                 elif 'pyzstd' in sys.modules:
-                    fp = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(infile, "r")
@@ -9219,37 +9237,37 @@ def ListDirListFiles(infiles, dirlistfromtxt=False, compression="auto", compress
 PyNeoFile compatibility layer
 """
 
-def make_empty_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8'):
+def make_empty_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8'):
     return MakeEmptyFilePointer(fp, fmttype, checksumtype, formatspecs)
 
-def make_empty_archive_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8'):
+def make_empty_archive_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8'):
     return make_empty_file_pointer_neo(fp, fmttype, checksumtype, formatspecs, encoding)
 
-def make_empty_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8', returnfp=False):
+def make_empty_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8', returnfp=False):
     return MakeEmptyFile(outfile, fmttype, "auto", False, None, checksumtype, formatspecs, returnfp)
 
-def make_empty_archive_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8', returnfp=False):
+def make_empty_archive_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8', returnfp=False):
     return make_empty_file_neo(outfile, fmttype, checksumtype, formatspecs, encoding, returnfp)
 
-def pack_neo(infiles, outfile=None, formatspecs=None, checksumtypes=["crc32", "crc32", "crc32", "crc32"], encoding="UTF-8", compression="auto", compression_level=None, returnfp=False):
+def pack_neo(infiles, outfile=None, formatspecs=__file_format_multi_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], encoding="UTF-8", compression="auto", compression_level=None, returnfp=False):
     return PackCatFile(infiles, outfile, False, "auto", compression, False, compression_level, compressionlistalt, False, checksumtypes, [], {}, formatspecs, False, returnfp)
 
-def archive_to_array_neo(infile, formatspecs=None, listonly=False, skipchecksum=False, uncompress=True, returnfp=False):
+def archive_to_array_neo(infile, formatspecs=__file_format_multi_dict__, listonly=False, skipchecksum=False, uncompress=True, returnfp=False):
     return CatFileToArray(infile, "auto", 0, 0, listonly, True, uncompress, skipchecksum, formatspecs, False, returnfp)
 
-def unpack_neo(infile, outdir='.', formatspecs=None, skipchecksum=False, uncompress=True, returnfp=False):
+def unpack_neo(infile, outdir='.', formatspecs=__file_format_multi_dict__, skipchecksum=False, uncompress=True, returnfp=False):
     return UnPackCatFile(infile, outdir, False, 0, 0, skipchecksum, formatspecs, True, True, False, False, returnfp)
 
-def repack_neo(infile, outfile=None, formatspecs=None, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
+def repack_neo(infile, outfile=None, formatspecs=__file_format_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
     return RePackCatFile(infile, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
 
-def archivefilevalidate_neo(infile, formatspecs=None, verbose=False, return_details=False, returnfp=False):
+def archivefilevalidate_neo(infile, formatspecs=__file_format_multi_dict__, verbose=False, return_details=False, returnfp=False):
     return CatFileValidate(infile, "auto", formatspecs, False, verbose, returnfp)
 
-def archivefilelistfiles_neo(infile, formatspecs=None, advanced=False, include_dirs=True, returnfp=False):
+def archivefilelistfiles_neo(infile, formatspecs=__file_format_multi_dict__, advanced=False, include_dirs=True, returnfp=False):
     return CatFileListFiles(infile, "auto", 0, 0, False, formatspecs, False, True, advanced, returnfp)
 
-def convert_foreign_to_neo(infile, outfile=None, formatspecs=None, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
+def convert_foreign_to_neo(infile, outfile=None, formatspecs=__file_format_multi_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
     intmp = InFileToArray(infile, 0, 0, False, True, False, formatspecs, False, False)
     return RePackCatFile(intmp, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
 
@@ -9773,9 +9791,9 @@ def upload_file_to_internet_file(ifp, url):
     return False
 
 
-def upload_file_to_internet_compress_file(ifp, url, compression="auto", compressionlevel=None, formatspecs=__file_format_dict__):
+def upload_file_to_internet_compress_file(ifp, url, compression="auto", compressionlevel=None, compressionuselist=compressionlistalt, formatspecs=__file_format_dict__):
     fp = CompressOpenFileAlt(
-        fp, compression, compressionlevel, formatspecs)
+        fp, compression, compressionlevel, compressionuselist, formatspecs)
     if(not archivefileout):
         return False
     fp.seek(0, 0)
@@ -9799,9 +9817,9 @@ def upload_file_to_internet_string(ifp, url):
     return False
 
 
-def upload_file_to_internet_compress_string(ifp, url, compression="auto", compressionlevel=None, formatspecs=__file_format_dict__):
+def upload_file_to_internet_compress_string(ifp, url, compression="auto", compressionlevel=None, compressionuselist=compressionlistalt, formatspecs=__file_format_dict__):
     fp = CompressOpenFileAlt(
-        BytesIO(ifp), compression, compressionlevel, formatspecs)
+        BytesIO(ifp), compression, compressionlevel, compressionuselist, formatspecs)
     if(not archivefileout):
         return False
     fp.seek(0, 0)