PyFoxFile 0.21.0__py3-none-any.whl → 0.21.2__py3-none-any.whl

{pyfoxfile-0.21.0.data → pyfoxfile-0.21.2.data}/scripts/foxfile.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: foxfile.py - Last Update: 8/20/2025 Ver. 0.20.2 RC 1 - Author: cooldude2k $
+    $FileInfo: foxfile.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
@@ -172,7 +172,7 @@ if active_action:
         if getargs.convert:
             checkcompressfile = pyfoxfile.CheckCompressionSubType(
                 input_file, fnamedict, True)
-            if((IsNestedDict(fnamedict) and checkcompressfile in fnamedict) or (IsSingleDict(fnamedict) and checkcompressfile==fnamedict['format_magic'])):
+            if((pyfoxfile.IsNestedDict(fnamedict) and checkcompressfile in fnamedict) or (pyfoxfile.IsSingleDict(fnamedict) and checkcompressfile==fnamedict['format_magic'])):
                 tmpout = pyfoxfile.RePackFoxFile(input_file, getargs.output, getargs.compression, getargs.wholefile, getargs.level, pyfoxfile.compressionlistalt, False, 0, 0, [getargs.checksum, getargs.checksum, getargs.checksum, getargs.checksum], getargs.skipchecksum, [], {}, fnamedict, getargs.verbose, False)
             else:
                 tmpout = pyfoxfile.PackFoxFileFromInFile(
@@ -185,7 +185,7 @@ if active_action:
         if getargs.convert:
             checkcompressfile = pyfoxfile.CheckCompressionSubType(
                 input_file, fnamedict, True)
-            if((IsNestedDict(fnamedict) and checkcompressfile in fnamedict) or (IsSingleDict(fnamedict) and checkcompressfile==fnamedict['format_magic'])):
+            if((pyfoxfile.IsNestedDict(fnamedict) and checkcompressfile in fnamedict) or (pyfoxfile.IsSingleDict(fnamedict) and checkcompressfile==fnamedict['format_magic'])):
                 pyfoxfile.RePackFoxFile(input_file, getargs.output, getargs.compression, getargs.wholefile, getargs.level, pyfoxfile.compressionlistalt,
                                             False, 0, 0, [getargs.checksum, getargs.checksum, getargs.checksum, getargs.checksum], getargs.skipchecksum, [], {}, fnamedict, getargs.verbose, False)
             else:
@@ -200,7 +200,7 @@ if active_action:
             checkcompressfile = pyfoxfile.CheckCompressionSubType(
                 input_file, fnamedict, True)
             tempout = BytesIO()
-            if((IsNestedDict(fnamedict) and checkcompressfile in fnamedict) or (IsSingleDict(fnamedict) and checkcompressfile==fnamedict['format_magic'])):
+            if((pyfoxfile.IsNestedDict(fnamedict) and checkcompressfile in fnamedict) or (pyfoxfile.IsSingleDict(fnamedict) and checkcompressfile==fnamedict['format_magic'])):
                 tmpout = pyfoxfile.RePackFoxFile(input_file, tempout, getargs.compression, getargs.wholefile, getargs.level, pyfoxfile.compressionlistalt, False, 0, 0, [getargs.checksum, getargs.checksum, getargs.checksum, getargs.checksum], getargs.skipchecksum, [], {}, fnamedict, False, False)
             else:
                 tmpout = pyfoxfile.PackFoxFileFromInFile(
@@ -214,7 +214,7 @@ if active_action:
         if getargs.convert:
             checkcompressfile = pyfoxfile.CheckCompressionSubType(
                 input_file, fnamedict, True)
-            if((IsNestedDict(fnamedict) and checkcompressfile in fnamedict) or (IsSingleDict(fnamedict) and checkcompressfile==fnamedict['format_magic'])):
+            if((pyfoxfile.IsNestedDict(fnamedict) and checkcompressfile in fnamedict) or (pyfoxfile.IsSingleDict(fnamedict) and checkcompressfile==fnamedict['format_magic'])):
                 tmpout = pyfoxfile.FoxFileListFiles(input_file, "auto", 0, 0, getargs.skipchecksum, fnamedict, False, getargs.verbose, False, False)
             else:
                 tmpout = pyfoxfile.InFileListFiles(input_file, getargs.verbose, fnamedict, False, False, False)
@@ -227,7 +227,7 @@ if active_action:
             checkcompressfile = pyfoxfile.CheckCompressionSubType(
                 input_file, fnamedict, True)
             tempout = BytesIO()
-            if((IsNestedDict(fnamedict) and checkcompressfile in fnamedict) or (IsSingleDict(fnamedict) and checkcompressfile==fnamedict['format_magic'])):
+            if((pyfoxfile.IsNestedDict(fnamedict) and checkcompressfile in fnamedict) or (pyfoxfile.IsSingleDict(fnamedict) and checkcompressfile==fnamedict['format_magic'])):
                 tmpout = pyfoxfile.RePackFoxFile(input_file, tempout, getargs.compression, getargs.wholefile, getargs.level, pyfoxfile.compressionlistalt, False, 0, 0, [getargs.checksum, getargs.checksum, getargs.checksum, getargs.checksum], getargs.skipchecksum, [], {}, fnamedict, False, False, False)
             else:
                 tmpout = pyfoxfile.PackFoxFileFromInFile(

{pyfoxfile-0.21.0.dist-info → pyfoxfile-0.21.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFoxFile
-Version: 0.21.0
+Version: 0.21.2
 Summary: A tar like file format name foxfile.
 Home-page: https://github.com/GameMaker2k/PyFoxFile
 Download-URL: https://github.com/GameMaker2k/PyFoxFile/archive/master.tar.gz

pyfoxfile-0.21.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+pyfoxfile.py,sha256=lFaP7fi4abwkaBMTxq-tZ4SXy_mmc9-P1jZza6gXj9k,440116
+pyfoxfile-0.21.2.data/scripts/foxfile.py,sha256=8iPQLXINZrRVYpuDRZ4OPIxyRrVRDQ2L83JJxfSoLbk,14094
+pyfoxfile-0.21.2.data/scripts/foxneofile.py,sha256=vrQsZFkSyq5TqQmakzz3AtvxAqQTECTcb9JTzWYDzng,5128
+pyfoxfile-0.21.2.data/scripts/neofoxfile.py,sha256=5_A2OgXuV7Yj0SAb5F2PysPneIBrqfuM8REjClRquN4,7113
+pyfoxfile-0.21.2.dist-info/licenses/LICENSE,sha256=WM1VWxTUVrQbvEa-LC7cKTaBHXiqSTyYPoJvsZSbd7E,1513
+pyfoxfile-0.21.2.dist-info/METADATA,sha256=Z1VdUPbIZh7HlrdHAxMF3xdXOHtvlXxJ_CotSDoXmOY,715
+pyfoxfile-0.21.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyfoxfile-0.21.2.dist-info/top_level.txt,sha256=VTOkpGfBWHNht7FKfnbccd32n_Jgk8Df5NKKfzaliTc,10
+pyfoxfile-0.21.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pyfoxfile-0.21.2.dist-info/RECORD,,

pyfoxfile.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: pyfoxfile.py - Last Update: 9/17/2025 Ver. 0.21.0 RC 1 - Author: cooldude2k $
+    $FileInfo: pyfoxfile.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
@@ -389,12 +389,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/PyFoxFile"
-__version_info__ = (0, 21, 0, "RC 1", 1)
-__version_date_info__ = (2025, 9, 17, "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: 6208d3cb66a43a7e1047211a926f92f6aecfff08 $"
+__revision_id__ = "$Id: c85d5aa829f172404f285788e6b35f73a35767c2 $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -1957,15 +1957,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)
@@ -2018,6 +2018,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))
@@ -2030,7 +2031,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)
@@ -2122,6 +2123,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")
@@ -2149,11 +2151,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]
@@ -2161,6 +2163,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 " +
@@ -2195,6 +2198,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))
@@ -2236,7 +2240,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
 
 
@@ -2333,11 +2337,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]
@@ -2547,11 +2551,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
@@ -2562,14 +2566,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))
@@ -2579,7 +2587,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 + "'")
@@ -2702,11 +2710,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
@@ -2721,16 +2729,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))
@@ -2817,13 +2829,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):
@@ -2933,13 +2945,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):
@@ -2978,7 +2990,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):
@@ -3005,13 +3017,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):
@@ -3121,13 +3133,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):
@@ -3166,7 +3178,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):
@@ -3211,7 +3223,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(
@@ -3265,11 +3277,11 @@ def MakeEmptyFilePointer(fp, fmttype=__file_format_default__, checksumtype="crc3
     return fp
 
 
-def MakeEmptyFoxFilePointer(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)
@@ -3313,7 +3325,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")):
@@ -3337,7 +3349,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):
@@ -3348,8 +3360,8 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
         return True
 
 
-def MakeEmptyFoxFile(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__):
@@ -3448,6 +3460,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())
@@ -3488,7 +3501,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"
@@ -3586,7 +3599,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()
@@ -3656,7 +3669,7 @@ 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())
@@ -3671,7 +3684,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):
@@ -3703,7 +3716,7 @@ 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())
@@ -3718,7 +3731,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):
@@ -3760,7 +3773,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]
@@ -3862,7 +3875,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")):
@@ -3886,7 +3899,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):
@@ -3942,7 +3955,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")):
@@ -3966,7 +3979,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):
@@ -4657,13 +4670,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()
@@ -4882,7 +4895,7 @@ def PackFoxFile(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",
@@ -5049,7 +5062,7 @@ def PackFoxFile(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()
@@ -5118,7 +5131,7 @@ def PackFoxFile(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())
@@ -5133,7 +5146,7 @@ def PackFoxFile(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):
@@ -5165,7 +5178,7 @@ def PackFoxFile(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())
@@ -5180,7 +5193,7 @@ def PackFoxFile(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):
@@ -5205,7 +5218,7 @@ def PackFoxFile(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")):
@@ -5229,7 +5242,7 @@ def PackFoxFile(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):
@@ -5267,7 +5280,7 @@ def PackFoxFileFromTarFile(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)
@@ -5342,7 +5355,7 @@ def PackFoxFileFromTarFile(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")
@@ -5354,7 +5367,7 @@ def PackFoxFileFromTarFile(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")
@@ -5446,6 +5459,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         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)
@@ -5465,7 +5479,7 @@ def PackFoxFileFromTarFile(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())
@@ -5480,7 +5494,7 @@ def PackFoxFileFromTarFile(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):
@@ -5505,7 +5519,7 @@ def PackFoxFileFromTarFile(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")):
@@ -5529,7 +5543,7 @@ def PackFoxFileFromTarFile(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):
@@ -5563,7 +5577,7 @@ def PackFoxFileFromZipFile(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)
@@ -5762,7 +5776,7 @@ def PackFoxFileFromZipFile(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()
@@ -5774,7 +5788,7 @@ def PackFoxFileFromZipFile(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):
@@ -5799,7 +5813,7 @@ def PackFoxFileFromZipFile(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")):
@@ -5823,7 +5837,7 @@ def PackFoxFileFromZipFile(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):
@@ -5862,7 +5876,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)
@@ -6079,7 +6093,7 @@ 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())
@@ -6094,12 +6108,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"):
@@ -6119,7 +6133,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")):
@@ -6143,7 +6157,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):
@@ -6182,7 +6196,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)
@@ -6309,13 +6323,14 @@ if(py7zr_support):
                 fgname = ""
             fcontents = BytesIO()
             fcencoding = "UTF-8"
-             curcompression = "none"
+            curcompression = "none"
             if ftype == 0:
                 fcontents.write(file_content[member.filename].read())
+                fsize = format(fcontents.tell(), 'x').lower()
+                fcontents.seek(0, 0)
                 typechecktest = CheckCompressionType(fcontents, closefp=False)
                 fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, False)
-                fsize = format(fcontents.tell(), 'x').lower()
                 file_content[member.filename].close()
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
@@ -6332,7 +6347,7 @@ 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())
@@ -6347,7 +6362,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):
@@ -6372,7 +6387,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")):
@@ -6396,7 +6411,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):
@@ -7593,11 +7608,11 @@ def FoxFileToArray(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
@@ -7888,7 +7903,7 @@ def MultipleFoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listo
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        curretfile = outretval.update({curfname: FoxFileToArray(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 MultipleFoxFilesToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
@@ -8072,7 +8087,7 @@ def RePackFoxFile(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)
@@ -8200,7 +8215,7 @@ def RePackFoxFile(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())
@@ -8215,7 +8230,7 @@ def RePackFoxFile(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):
@@ -8295,7 +8310,7 @@ def RePackFoxFile(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")):
@@ -8319,7 +8334,7 @@ def RePackFoxFile(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):
@@ -8728,7 +8743,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")
@@ -8740,7 +8755,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")
@@ -9774,9 +9789,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 foxfileout):
         return False
     fp.seek(0, 0)
@@ -9800,9 +9815,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 foxfileout):
         return False
     fp.seek(0, 0)

pyfoxfile-0.21.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-pyfoxfile.py,sha256=oIhDTp0KQS3IPVe31EYOaFiV8KJ6f2wcajf5yHoXqJI,438678
-pyfoxfile-0.21.0.data/scripts/foxfile.py,sha256=jVbflioQQRu6dy85bt8QW9OfXr5rzfmmQ75qM-Q31u4,13994
-pyfoxfile-0.21.0.data/scripts/foxneofile.py,sha256=vrQsZFkSyq5TqQmakzz3AtvxAqQTECTcb9JTzWYDzng,5128
-pyfoxfile-0.21.0.data/scripts/neofoxfile.py,sha256=5_A2OgXuV7Yj0SAb5F2PysPneIBrqfuM8REjClRquN4,7113
-pyfoxfile-0.21.0.dist-info/licenses/LICENSE,sha256=WM1VWxTUVrQbvEa-LC7cKTaBHXiqSTyYPoJvsZSbd7E,1513
-pyfoxfile-0.21.0.dist-info/METADATA,sha256=1ih5Mo2bfBGsLzDCMVW8u1aUj3lVcNxy3hnK7raC6o0,715
-pyfoxfile-0.21.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyfoxfile-0.21.0.dist-info/top_level.txt,sha256=VTOkpGfBWHNht7FKfnbccd32n_Jgk8Df5NKKfzaliTc,10
-pyfoxfile-0.21.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pyfoxfile-0.21.0.dist-info/RECORD,,