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

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/26/2025 Ver. 0.21.4 RC 1 - Author: cooldude2k $
 '''
 
 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
@@ -32,10 +32,12 @@ import socket
 import hashlib
 import inspect
 import datetime
+import tempfile
 import logging
 import zipfile
 import binascii
 import platform
+from io import StringIO, BytesIO
 try:
     from backports import tempfile
 except ImportError:
@@ -243,17 +245,6 @@ except ImportError:
     from urllib2 import Request, build_opener, HTTPBasicAuthHandler
     from urlparse import urlparse
 
-# StringIO and BytesIO
-try:
-    from io import StringIO, BytesIO
-except ImportError:
-    try:
-        from cStringIO import StringIO
-        from cStringIO import StringIO as BytesIO
-    except ImportError:
-        from StringIO import StringIO
-        from StringIO import StringIO as BytesIO
-
 def get_importing_script_path():
     # Inspect the stack and get the frame of the caller
     stack = inspect.stack()
@@ -275,22 +266,6 @@ def get_default_threads():
 
 
 __use_pysftp__ = False
-__use_alt_format__ = False
-__use_env_file__ = True
-__use_ini_file__ = True
-__use_ini_name__ = "foxfile.ini"
-if('PYARCHIVEFILE_CONFIG_FILE' in os.environ and os.path.exists(os.environ['PYARCHIVEFILE_CONFIG_FILE']) and __use_env_file__):
-    scriptconf = os.environ['PYARCHIVEFILE_CONFIG_FILE']
-else:
-    prescriptpath = get_importing_script_path()
-    if(prescriptpath is not None):
-        scriptconf = os.path.join(os.path.dirname(prescriptpath), __use_ini_name__)
-    else:
-        scriptconf = ""
-if os.path.exists(scriptconf):
-    __config_file__ = scriptconf
-else:
-    __config_file__ = os.path.join(os.path.dirname(os.path.realpath(__file__)), __use_ini_name__)
 if(not havepysftp):
     __use_pysftp__ = False
 __use_http_lib__ = "httpx"
@@ -328,7 +303,25 @@ def is_only_nonprintable(var):
 __file_format_multi_dict__ = {}
 __file_format_default__ = "FoxFile"
 __include_defaults__ = True
+__use_inmemfile__ = False
 __program_name__ = "Py"+__file_format_default__
+__use_env_file__ = True
+__use_ini_file__ = True
+__use_ini_name__ = "foxfile.ini"
+__use_json_file__ = False
+__use_json_name__ = "foxfile.json"
+if('PYARCHIVEFILE_CONFIG_FILE' in os.environ and os.path.exists(os.environ['PYARCHIVEFILE_CONFIG_FILE']) and __use_env_file__):
+    scriptconf = os.environ['PYARCHIVEFILE_CONFIG_FILE']
+else:
+    prescriptpath = get_importing_script_path()
+    if(prescriptpath is not None):
+        scriptconf = os.path.join(os.path.dirname(prescriptpath), __use_ini_name__)
+    else:
+        scriptconf = ""
+if os.path.exists(scriptconf):
+    __config_file__ = scriptconf
+else:
+    __config_file__ = os.path.join(os.path.dirname(os.path.realpath(__file__)), __use_ini_name__)
 if __use_ini_file__ and os.path.exists(__config_file__):
     config = configparser.ConfigParser()
     config.read(__config_file__)
@@ -340,6 +333,7 @@ if __use_ini_file__ and os.path.exists(__config_file__):
     __file_format_default__ = decode_unicode_escape(config.get('config', 'default'))
     __program_name__ = decode_unicode_escape(config.get('config', 'proname'))
     __include_defaults__ = config.getboolean('config', 'includedef')
+    __use_inmemfile__ = config.getboolean('config', 'inmemfile')
     # Loop through all sections
     for section in config.sections():
         required_keys = [
@@ -389,12 +383,13 @@ __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, 4, "RC 1", 1)
+__version_info__ = (0, 21, 4, "RC 1", 1)
+__version_date_info__ = (2025, 9, 26, "RC 1", 1)
 __version_date__ = str(__version_date_info__[0]) + "." + str(
     __version_date_info__[1]).zfill(2) + "." + str(__version_date_info__[2]).zfill(2)
 __revision__ = __version_info__[3]
-__revision_id__ = "$Id: 6208d3cb66a43a7e1047211a926f92f6aecfff08 $"
+__revision_id__ = "$Id: 9911cc0b37bf3b39652ce61ec29c1e2180f46e43 $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -584,6 +579,105 @@ def VerbosePrintOutReturn(dbgtxt, outtype="log", dbgenable=True, dgblevel=20):
     return dbgtxt
 
 
+# --- Helpers ---
+def _normalize_initial_data(data, isbytes, encoding):
+    """Return data in the correct type for write(): bytes (if isbytes) or text (if not)."""
+    if data is None:
+        return None
+
+    if isbytes:
+        # Want bytes
+        if isinstance(data, bytes):
+            return data
+        # Py2: str is already bytes, unicode needs encode
+        if sys.version_info[0] == 2:
+            try:
+                unicode  # noqa: F821
+            except NameError:
+                pass
+            else:
+                if isinstance(data, unicode):  # noqa: F821
+                    return data.encode(encoding)
+        # Py3 str -> encode
+        return str(data).encode(encoding)
+    else:
+        # Want text (unicode/str)
+        if sys.version_info[0] == 2:
+            try:
+                unicode  # noqa: F821
+                if isinstance(data, unicode):  # noqa: F821
+                    return data
+                # bytes/str -> decode
+                return data.decode(encoding) if isinstance(data, str) else unicode(data)  # noqa: F821
+            except NameError:
+                # Very defensive; shouldn't happen
+                return data
+        else:
+            # Py3: want str
+            if isinstance(data, bytes):
+                return data.decode(encoding)
+            return str(data)
+
+
+def MkTempFile(data=None, inmem=__use_inmemfile__, isbytes=True, prefix=__project__,
+               delete=True, encoding="utf-8"):
+    """
+    Return a file-like handle.
+      - If inmem=True: returns StringIO (text) or BytesIO (bytes).
+      - If inmem=False: returns a NamedTemporaryFile opened in text or binary mode.
+    Args:
+      data:     optional initial content; if provided, it's written and the handle is seek(0)
+      inmem:    bool — return in-memory handle if True
+      isbytes:  bool — choose bytes (True) or text (False)
+      prefix:   str  — tempfile prefix
+      delete:   bool — whether the tempfile is deleted on close (NamedTemporaryFile)
+      encoding: str  — used for text mode (and for conversions when needed)
+    """
+    init = _normalize_initial_data(data, isbytes, encoding)
+
+    if inmem:
+        buf = BytesIO() if isbytes else StringIO()
+        if init is not None:
+            buf.write(init)
+            buf.seek(0)
+        return buf
+
+    mode = "wb+" if isbytes else "w+"
+    kwargs = {"prefix": prefix or "", "delete": delete, "mode": mode}
+
+    # Only Python 3's text-mode files accept encoding/newline explicitly
+    if not isbytes and sys.version_info[0] >= 3:
+        kwargs["encoding"] = encoding
+        kwargs["newline"] = ""
+
+    f = tempfile.NamedTemporaryFile(**kwargs)
+
+    if init is not None:
+        f.write(init)
+        f.seek(0)
+    return f
+
+
+def MkTempFileSmart(data=None, isbytes=True, prefix=__project__, max_mem=1024*1024, encoding="utf-8"):
+    """
+    Spooled temp file: starts in memory and spills to disk past max_mem.
+    Behaves like BytesIO/StringIO for small data, with the same preload+seek(0) behavior.
+    """
+    mode = "wb+" if isbytes else "w+"
+    kwargs = {"mode": mode, "max_size": max_mem, "prefix": prefix or ""}
+    if not isbytes and sys.version_info[0] >= 3:
+        kwargs["encoding"] = encoding
+        kwargs["newline"] = ""
+
+    f = tempfile.SpooledTemporaryFile(**kwargs)
+
+    init = _normalize_initial_data(data, isbytes, encoding)
+    if init is not None:
+        f.write(init)
+        f.seek(0)
+    return f
+
+
 def RemoveWindowsPath(dpath):
     """
     Normalize a path by converting backslashes to forward slashes
@@ -1920,7 +2014,7 @@ def ReadFileHeaderDataBySize(fp, delimiter=__file_format_dict__['format_delimite
     headersize = int(preheaderdata[0], 16)
     if(headersize <= 0):
         return []
-    subfp = BytesIO()
+    subfp = MkTempFile()
     subfp.write(fp.read(headersize))
     fp.seek(len(delimiter), 1)
     subfp.seek(0, 0)
@@ -1957,15 +2051,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)
@@ -2004,7 +2098,7 @@ def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipcheck
         return False
     fhend = fp.tell() - 1
     fcontentstart = fp.tell()
-    fcontents = BytesIO()
+    fcontents = MkTempFile()
     if(fsize > 0 and not listonly):
         if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
             fcontents.write(fp.read(fsize))
@@ -2018,6 +2112,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 +2125,7 @@ def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipcheck
         if(uncompress):
             cfcontents = UncompressFileAlt(fcontents, formatspecs)
             cfcontents.seek(0, 0)
-            cfcontents.seek(0, 0)
+            fcontents = MkTempFile()
             shutil.copyfileobj(cfcontents, fcontents)
             cfcontents.close()
             fcontents.seek(0, 0)
@@ -2122,6 +2217,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")
@@ -2143,17 +2239,17 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
             fjsoncontent = {}
     elif(fjsontype=="list"):
         fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
-        flisttmp = BytesIO()
+        flisttmp = MkTempFile()
         flisttmp.write(fprejsoncontent.encode())
         flisttmp.seek(0)
         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 +2257,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 " +
@@ -2178,7 +2275,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
         return False
     fhend = fp.tell() - 1
     fcontentstart = fp.tell()
-    fcontents = BytesIO()
+    fcontents = MkTempFile()
     pyhascontents = False
     if(fsize > 0 and not listonly):
         if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
@@ -2195,6 +2292,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))
@@ -2208,7 +2306,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
             cfcontents = UncompressFileAlt(
                 fcontents, formatspecs)
             cfcontents.seek(0, 0)
-            fcontents = BytesIO()
+            fcontents = MkTempFile()
             shutil.copyfileobj(cfcontents, fcontents)
             cfcontents.close()
             fcontents.seek(0, 0)
@@ -2236,7 +2334,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
 
 
@@ -2327,17 +2425,17 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
             fjsoncontent = {}
     elif(fjsontype=="list"):
         fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
-        flisttmp = BytesIO()
+        flisttmp = MkTempFile()
         flisttmp.write(fprejsoncontent.encode())
         flisttmp.seek(0)
         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]
@@ -2362,7 +2460,7 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
         return False
     fhend = fp.tell() - 1
     fcontentstart = fp.tell()
-    fcontents = BytesIO()
+    fcontents = MkTempFile()
     pyhascontents = False
     if(fsize > 0 and not listonly):
         if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
@@ -2392,7 +2490,7 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
             cfcontents = UncompressFileAlt(
                 fcontents, formatspecs)
             cfcontents.seek(0, 0)
-            fcontents = BytesIO()
+            fcontents = MkTempFile()
             shutil.copyfileobj(cfcontents, fcontents)
             cfcontents.close()
             fcontents.seek(0, 0)
@@ -2547,11 +2645,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 +2660,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 +2681,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 + "'")
@@ -2588,7 +2690,7 @@ def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, c
                 invalid_archive = True
             prefhend = fp.tell() - 1
             prefcontentstart = fp.tell()
-            prefcontents = BytesIO()
+            prefcontents = MkTempFile()
             pyhascontents = False
             if(prefsize > 0):
                 prefcontents.write(fp.read(prefsize))
@@ -2702,11 +2804,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 +2823,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 +2923,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):
@@ -2852,7 +2958,7 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
                 return False
         fp.seek(0, 0)
     elif(infile == "-"):
-        fp = BytesIO()
+        fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
@@ -2873,7 +2979,7 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
             return False
         fp.seek(0, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = BytesIO()
+        fp = MkTempFile()
         fp.write(infile)
         fp.seek(0, 0)
         fp = UncompressFileAlt(fp, formatspecs)
@@ -2933,13 +3039,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 +3084,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 +3111,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):
@@ -3040,7 +3146,7 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
                 return False
         fp.seek(0, 0)
     elif(infile == "-"):
-        fp = BytesIO()
+        fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
@@ -3061,7 +3167,7 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
             return False
         fp.seek(0, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = BytesIO()
+        fp = MkTempFile()
         fp.write(infile)
         fp.seek(0, 0)
         fp = UncompressFileAlt(fp, formatspecs)
@@ -3121,13 +3227,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 +3272,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 +3317,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(
@@ -3269,7 +3375,7 @@ def MakeEmptyFoxFilePointer(fp, fmttype=__file_format_default__, checksumtype="c
     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)
@@ -3296,11 +3402,11 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
                 pass
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -3313,7 +3419,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 +3443,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 +3454,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 MakeEmptyFoxFile(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 +3554,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 +3595,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 +3693,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()
@@ -3631,7 +3738,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
             fwinattributes = format(int(0), 'x').lower()
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
-        fcontents = BytesIO()
+        fcontents = MkTempFile()
         chunk_size = 1024
         fcencoding = "UTF-8"
         curcompression = "none"
@@ -3650,13 +3757,13 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                         ilmin = 0
                         ilcsize = []
                         while(ilmin < ilsize):
-                            cfcontents = BytesIO()
+                            cfcontents = MkTempFile()
                             fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             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())
@@ -3667,11 +3774,11 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
                     fcontents.seek(0, 0)
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     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):
@@ -3697,13 +3804,13 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                         ilmin = 0
                         ilcsize = []
                         while(ilmin < ilsize):
-                            cfcontents = BytesIO()
+                            cfcontents = MkTempFile()
                             fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             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())
@@ -3714,11 +3821,11 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
                     fcontents.seek(0, 0)
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     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 +3867,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]
@@ -3844,11 +3951,11 @@ def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, fmtt
                 pass
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -3862,7 +3969,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 +3993,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):
@@ -3924,11 +4031,11 @@ def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, fmtty
                 pass
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -3942,7 +4049,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 +4073,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):
@@ -4045,7 +4152,7 @@ def GzipCompressData(data, compresslevel=9):
         compressed_data = gzip.compress(data, compresslevel=compresslevel)
     except AttributeError:
         # Fallback to older method for Python 2.x and older 3.x versions
-        out = BytesIO()
+        out = MkTempFile()
         with gzip.GzipFile(fileobj=out, mode="wb", compresslevel=compresslevel) as f:
             f.write(data)
         compressed_data = out.getvalue()
@@ -4058,7 +4165,7 @@ def GzipDecompressData(compressed_data):
         decompressed_data = gzip.decompress(compressed_data)
     except AttributeError:
         # Fallback to older method for Python 2.x and older 3.x versions
-        inp = BytesIO(compressed_data)
+        inp = MkTempFile(compressed_data)
         with gzip.GzipFile(fileobj=inp, mode="rb") as f:
             decompressed_data = f.read()
     return decompressed_data
@@ -4191,9 +4298,9 @@ def GetFileEncoding(infile, closefp=True):
 
 def GetFileEncodingFromString(instring, closefp=True):
     try:
-        instringsfile = BytesIO(instring)
+        instringsfile = MkTempFile(instring)
     except TypeError:
-        instringsfile = BytesIO(instring.encode("UTF-8"))
+        instringsfile = MkTempFile(instring.encode("UTF-8"))
     return GetFileEncoding(instringsfile, closefp)
 
 
@@ -4456,17 +4563,17 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, clos
 
 def CheckCompressionTypeFromString(instring, formatspecs=__file_format_multi_dict__, closefp=True):
     try:
-        instringsfile = BytesIO(instring)
+        instringsfile = MkTempFile(instring)
     except TypeError:
-        instringsfile = BytesIO(instring.encode("UTF-8"))
+        instringsfile = MkTempFile(instring.encode("UTF-8"))
     return CheckCompressionType(instringsfile, formatspecs, closefp)
 
 
 def CheckCompressionTypeFromBytes(instring, formatspecs=__file_format_multi_dict__, closefp=True):
     try:
-        instringsfile = BytesIO(instring)
+        instringsfile = MkTempFile(instring)
     except TypeError:
-        instringsfile = BytesIO(instring.decode("UTF-8"))
+        instringsfile = MkTempFile(instring.decode("UTF-8"))
     return CheckCompressionType(instringsfile, formatspecs, closefp)
 
 
@@ -4633,7 +4740,7 @@ def UncompressBytes(infile, formatspecs=__file_format_multi_dict__):
 
 
 def UncompressBytesAlt(inbytes, formatspecs=__file_format_multi_dict__):
-    filefp = BytesIO()
+    filefp = MkTempFile()
     outstring = UncompressBytes(inbytes, formatspecs)
     filefp.write(outstring)
     filefp.seek(0, 0)
@@ -4649,7 +4756,7 @@ def UncompressBytesAltFP(fp, formatspecs=__file_format_multi_dict__):
     fp.seek(0, 0)
     if(prechck!="zstd"):
         return UncompressFileAlt(fp, formatspecs)
-    filefp = BytesIO()
+    filefp = MkTempFile()
     fp.seek(0, 0)
     outstring = UncompressBytes(fp.read(), formatspecs)
     filefp.write(outstring)
@@ -4657,16 +4764,16 @@ 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()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4674,7 +4781,7 @@ def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, formatspe
         bytesfp.write(GzipCompressData(
             fp.read(), compresslevel=compressionlevel))
     elif(compression == "bzip2" and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4682,7 +4789,7 @@ def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, formatspe
         bytesfp.write(BzipCompressData(
             fp.read(), compresslevel=compressionlevel))
     elif(compression == "lz4" and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4690,14 +4797,14 @@ def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, formatspe
         bytesfp.write(lz4.frame.compress(
             fp.read(), compression_level=compressionlevel))
     elif((compression == "lzo" or compression == "lzop") and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
             compressionlevel = int(compressionlevel)
         bytesfp.write(lzo.compress(fp.read(), compressionlevel))
     elif(compression == "zstd" and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4705,7 +4812,7 @@ def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, formatspe
         compressor = zstandard.ZstdCompressor(compressionlevel, threads=get_default_threads())
         bytesfp.write(compressor.compress(fp.read()))
     elif(compression == "lzma" and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4715,7 +4822,7 @@ def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, formatspe
         except (NotImplementedError, lzma.LZMAError):
             bytesfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_ALONE))
     elif(compression == "xz" and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4725,7 +4832,7 @@ def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, formatspe
         except (NotImplementedError, lzma.LZMAError):
             bytesfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_XZ))
     elif(compression == "zlib" and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4882,7 +4989,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",
@@ -4895,11 +5002,11 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                 pass
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -5049,7 +5156,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()
@@ -5094,7 +5201,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
             fwinattributes = format(int(0), 'x').lower()
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
-        fcontents = BytesIO()
+        fcontents = MkTempFile()
         fcencoding = "UTF-8"
         curcompression = "none"
         if not followlink and ftype in data_types:
@@ -5112,13 +5219,13 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         ilmin = 0
                         ilcsize = []
                         while(ilmin < ilsize):
-                            cfcontents = BytesIO()
+                            cfcontents = MkTempFile()
                             fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             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())
@@ -5129,11 +5236,11 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
                     fcontents.seek(0, 0)
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     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):
@@ -5159,13 +5266,13 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         ilmin = 0
                         ilcsize = []
                         while(ilmin < ilsize):
-                            cfcontents = BytesIO()
+                            cfcontents = MkTempFile()
                             fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             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())
@@ -5176,11 +5283,11 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
                     fcontents.seek(0, 0)
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     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 +5312,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 +5336,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 +5374,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)
@@ -5279,11 +5386,11 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                 pass
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -5302,7 +5409,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
     filetoinode = {}
     inodetoforminode = {}
     if(infile == "-"):
-        infile = BytesIO()
+        infile = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, infile)
         else:
@@ -5342,7 +5449,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 +5461,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")
@@ -5441,12 +5548,13 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         fwinattributes = format(int(0), 'x').lower()
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
-        fcontents = BytesIO()
+        fcontents = MkTempFile()
         fcencoding = "UTF-8"
         curcompression = "none"
         if ftype in data_types:
             fpc = tarfp.extractfile(member)
             shutil.copyfileobj(fpc, fcontents)
+            fpc.close()
             typechecktest = CheckCompressionType(fcontents, closefp=False)
             fcontents.seek(0, 0)
             fcencoding = GetFileEncoding(fcontents, False)
@@ -5459,13 +5567,13 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                     ilmin = 0
                     ilcsize = []
                     while(ilmin < ilsize):
-                        cfcontents = BytesIO()
+                        cfcontents = MkTempFile()
                         fcontents.seek(0, 0)
                         shutil.copyfileobj(fcontents, cfcontents)
                         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())
@@ -5476,11 +5584,11 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                     ilcmin = ilcsize.index(min(ilcsize))
                     curcompression = compressionuselist[ilcmin]
                 fcontents.seek(0, 0)
-                cfcontents = BytesIO()
+                cfcontents = MkTempFile()
                 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 +5613,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 +5637,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 +5671,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)
@@ -5575,11 +5683,11 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
                 pass
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -5598,7 +5706,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
     filetoinode = {}
     inodetoforminode = {}
     if(infile == "-"):
-        infile = BytesIO()
+        infile = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, infile)
         else:
@@ -5739,7 +5847,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
                 fgname = ""
         except ImportError:
             fgname = ""
-        fcontents = BytesIO()
+        fcontents = MkTempFile()
         fcencoding = "UTF-8"
         curcompression = "none"
         if ftype == 0:
@@ -5756,13 +5864,13 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
                     ilmin = 0
                     ilcsize = []
                     while(ilmin < ilsize):
-                        cfcontents = BytesIO()
+                        cfcontents = MkTempFile()
                         fcontents.seek(0, 0)
                         shutil.copyfileobj(fcontents, cfcontents)
                         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()
@@ -5770,11 +5878,11 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
                     ilcmin = ilcsize.index(min(ilcsize))
                     curcompression = compressionuselist[ilcmin]
                 fcontents.seek(0, 0)
-                cfcontents = BytesIO()
+                cfcontents = MkTempFile()
                 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 +5907,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 +5931,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 +5970,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)
@@ -5874,11 +5982,11 @@ if(rarfile_support):
                     pass
         if(outfile == "-" or outfile is None):
             verbose = False
-            fp = BytesIO()
+            fp = MkTempFile()
         elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = outfile
         elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-            fp = BytesIO()
+            fp = MkTempFile()
         else:
             fbasename = os.path.splitext(outfile)[0]
             fextname = os.path.splitext(outfile)[1]
@@ -6056,7 +6164,7 @@ if(rarfile_support):
                     fgname = ""
             except ImportError:
                 fgname = ""
-            fcontents = BytesIO()
+            fcontents = MkTempFile()
             fcencoding = "UTF-8"
             curcompression = "none"
             if ftype == 0:
@@ -6073,13 +6181,13 @@ if(rarfile_support):
                         ilmin = 0
                         ilcsize = []
                         while(ilmin < ilsize):
-                            cfcontents = BytesIO()
+                            cfcontents = MkTempFile()
                             fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             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())
@@ -6090,16 +6198,16 @@ if(rarfile_support):
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
                     fcontents.seek(0, 0)
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     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 +6227,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 +6251,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 +6290,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)
@@ -6194,11 +6302,11 @@ if(py7zr_support):
                     pass
         if(outfile == "-" or outfile is None):
             verbose = False
-            fp = BytesIO()
+            fp = MkTempFile()
         elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = outfile
         elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-            fp = BytesIO()
+            fp = MkTempFile()
         else:
             fbasename = os.path.splitext(outfile)[0]
             fextname = os.path.splitext(outfile)[1]
@@ -6307,15 +6415,16 @@ if(py7zr_support):
                     fgname = ""
             except ImportError:
                 fgname = ""
-            fcontents = BytesIO()
+            fcontents = MkTempFile()
             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)
@@ -6326,13 +6435,13 @@ if(py7zr_support):
                         ilmin = 0
                         ilcsize = []
                         while(ilmin < ilsize):
-                            cfcontents = BytesIO()
+                            cfcontents = MkTempFile()
                             fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             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())
@@ -6343,11 +6452,11 @@ if(py7zr_support):
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
                     fcontents.seek(0, 0)
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     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 +6481,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 +6505,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):
@@ -6458,7 +6567,7 @@ def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, conte
             return False
         fp.seek(0, 0)
     elif(infile == "-"):
-        fp = BytesIO()
+        fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
@@ -6472,7 +6581,7 @@ def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, conte
             return False
         fp.seek(0, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = BytesIO()
+        fp = MkTempFile()
         fp.write(infile)
         fp.seek(0, 0)
         fp = UncompressFileAlt(fp, formatspecs)
@@ -6773,7 +6882,7 @@ def FoxFileSeekToFileName(infile, fmttype="auto", seekfile=None, listonly=False,
             return False
         fp.seek(0, 0)
     elif(infile == "-"):
-        fp = BytesIO()
+        fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
@@ -6787,7 +6896,7 @@ def FoxFileSeekToFileName(infile, fmttype="auto", seekfile=None, listonly=False,
             return False
         fp.seek(0, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = BytesIO()
+        fp = MkTempFile()
         fp.write(infile)
         fp.seek(0, 0)
         fp = UncompressFileAlt(fp, formatspecs)
@@ -7094,7 +7203,7 @@ def FoxFileValidate(infile, fmttype="auto", formatspecs=__file_format_multi_dict
             return False
         fp.seek(0, 0)
     elif(infile == "-"):
-        fp = BytesIO()
+        fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
@@ -7108,7 +7217,7 @@ def FoxFileValidate(infile, fmttype="auto", formatspecs=__file_format_multi_dict
             return False
         fp.seek(0, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = BytesIO()
+        fp = MkTempFile()
         fp.write(infile)
         fp.seek(0, 0)
         fp = UncompressFileAlt(fp, formatspecs)
@@ -7446,7 +7555,7 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
             return False
         fp.seek(0, 0)
     elif(infile == "-"):
-        fp = BytesIO()
+        fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
@@ -7460,7 +7569,7 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
             return False
         fp.seek(0, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = BytesIO()
+        fp = MkTempFile()
         fp.write(infile)
         fp.seek(0, 0)
         fp = UncompressFileAlt(fp, formatspecs)
@@ -7593,11 +7702,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
@@ -7760,7 +7869,7 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
                 outfjsoncontent = {}
         elif(outfjsontype=="list"):
             outfprejsoncontent = fp.read(outfjsonsize).decode("UTF-8")
-            flisttmp = BytesIO()
+            flisttmp = MkTempFile()
             flisttmp.write(outfprejsoncontent.encode())
             flisttmp.seek(0)
             outfjsoncontent = ReadFileHeaderData(flisttmp, outfjsonlen, formatspecs['format_delimiter'])
@@ -7813,7 +7922,7 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
                 VerbosePrintOut("'" + outfjsonchecksum + "' != " + "'" + injsonfcs + "'")
                 return False
         outfcontentstart = fp.tell()
-        outfcontents = BytesIO()
+        outfcontents = MkTempFile()
         pyhascontents = False
         if(outfsize > 0 and not listonly):
             if(outfcompression == "none" or outfcompression == "" or outfcompression == "auto"):
@@ -7838,7 +7947,7 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
                     cfcontents = UncompressFileAlt(
                         outfcontents, formatspecs)
                     cfcontents.seek(0, 0)
-                    outfcontents = BytesIO()
+                    outfcontents = MkTempFile()
                     shutil.copyfileobj(cfcontents, outfcontents)
                     cfcontents.close()
                     outfcontents.seek(0, 0)
@@ -7888,7 +7997,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] = FoxFileToArray(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):
@@ -7899,7 +8008,7 @@ def FoxFileStringToArray(instr, seekstart=0, seekend=0, listonly=False, contenta
     checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
-    fp = BytesIO(instr)
+    fp = MkTempFile(instr)
     listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
     return listfoxfiles
 
@@ -7908,7 +8017,7 @@ def TarFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile
     checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
-    fp = BytesIO()
+    fp = MkTempFile()
     fp = PackFoxFileFromTarFile(
         infile, fp, "auto", True, None, compressionlistalt, "crc32", [], formatspecs, False, True)
     listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
@@ -7919,7 +8028,7 @@ def ZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile
     checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
-    fp = BytesIO()
+    fp = MkTempFile()
     fp = PackFoxFileFromZipFile(
         infile, fp, "auto", True, None, compressionlistalt, "crc32", [], formatspecs, False, True)
     listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
@@ -7935,7 +8044,7 @@ if(rarfile_support):
         checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
-        fp = BytesIO()
+        fp = MkTempFile()
         fp = PackFoxFileFromRarFile(
             infile, fp, "auto", True, None, compressionlistalt, "crc32", [], formatspecs, False, True)
         listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
@@ -7950,7 +8059,7 @@ if(py7zr_support):
         checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
-        fp = BytesIO()
+        fp = MkTempFile()
         fp = PackFoxFileFromSevenZipFile(
             infile, fp, "auto", True, None, compressionlistalt, "crc32", [], formatspecs, False, True)
         listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
@@ -7977,7 +8086,7 @@ def InFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=
 
 
 def ListDirToArray(infiles, dirlistfromtxt=False, fmttype=__file_format_default__, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, seekstart=0, seekend=0, listonly=False, skipchecksum=False, checksumtype=["crc32", "crc32", "crc32"], extradata=[], formatspecs=__file_format_dict__, verbose=False, seektoend=False, returnfp=False):
-    outarray = BytesIO()
+    outarray = MkTempFile()
     packform = PackFoxFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile,
                               compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True)
     listfoxfiles = FoxFileToArray(outarray, "auto", seekstart, seekend, listonly, True, skipchecksum, formatspecs, seektoend, returnfp)
@@ -8072,7 +8181,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)
@@ -8086,11 +8195,11 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
         return False
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -8178,7 +8287,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
             jsondata = listfoxfiles['ffilelist'][reallcfi]['fjsondata']
         fcontents = listfoxfiles['ffilelist'][reallcfi]['fcontents']
         if(not listfoxfiles['ffilelist'][reallcfi]['fcontentasfile']):
-            fcontents = BytesIO(fcontents)
+            fcontents = MkTempFile(fcontents)
         typechecktest = CheckCompressionType(fcontents, closefp=False)
         fcontents.seek(0, 0)
         fcencoding = GetFileEncoding(fcontents, False)
@@ -8194,13 +8303,13 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 ilmin = 0
                 ilcsize = []
                 while(ilmin < ilsize):
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     fcontents.seek(0, 0)
                     shutil.copyfileobj(fcontents, cfcontents)
                     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())
@@ -8211,11 +8320,11 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 ilcmin = ilcsize.index(min(ilcsize))
                 curcompression = compressionuselist[ilcmin]
             fcontents.seek(0, 0)
-            cfcontents = BytesIO()
+            cfcontents = MkTempFile()
             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):
@@ -8224,10 +8333,10 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 fcontents.close()
                 fcontents = cfcontents
         if followlink:
-            if(listarchivefiles['ffilelist'][reallcfi]['ftype'] == 1 or listarchivefiles['ffilelist'][reallcfi]['ftype'] == 2):
-                getflinkpath = listarchivefiles['ffilelist'][reallcfi]['flinkname']
-                flinkid = prelistarchivefiles['filetoid'][getflinkpath]
-                flinkinfo = listarchivefiles['ffilelist'][flinkid]
+            if(listfoxfiles['ffilelist'][reallcfi]['ftype'] == 1 or listfoxfiles['ffilelist'][reallcfi]['ftype'] == 2):
+                getflinkpath = listfoxfiles['ffilelist'][reallcfi]['flinkname']
+                flinkid = prelistfoxfiles['filetoid'][getflinkpath]
+                flinkinfo = listfoxfiles['ffilelist'][flinkid]
                 fheadersize = format(
                     int(flinkinfo['fheadersize']), 'x').lower()
                 fsize = format(int(flinkinfo['fsize']), 'x').lower()
@@ -8260,11 +8369,11 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                     extradata = flinkinfo['fjsondata']
                 fcontents = flinkinfo['fcontents']
                 if(not flinkinfo['fcontentasfile']):
-                    fcontents = BytesIO(fcontents)
+                    fcontents = MkTempFile(fcontents)
                 ftypehex = format(flinkinfo['ftype'], 'x').lower()
         else:
             ftypehex = format(
-                listarchivefiles['ffilelist'][reallcfi]['ftype'], 'x').lower()
+                listfoxfiles['ffilelist'][reallcfi]['ftype'], 'x').lower()
         fcurfid = format(curfid, 'x').lower()
         if(not followlink and finode != 0):
             if(listfoxfiles['ffilelist'][reallcfi]['ftype'] != 1):
@@ -8295,7 +8404,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 +8428,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):
@@ -8331,14 +8440,14 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
 
 
 def RePackFoxFileFromString(instr, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["crc32", "crc32", "crc32"], skipchecksum=False, extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-    fp = BytesIO(instr)
+    fp = MkTempFile(instr)
     listfoxfiles = RePackFoxFile(fp, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist,
                                      checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp)
     return listfoxfiles
 
 
 def PackFoxFileFromListDir(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, skipchecksum=False, checksumtype=["crc32", "crc32", "crc32"], extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-    outarray = BytesIO()
+    outarray = MkTempFile()
     packform = PackFoxFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile,
                               compressionlevel, compressionuselist, followlink, checksumtype, extradata, formatspecs, verbose, True)
     listfoxfiles = RePackFoxFile(outarray, outfile, fmttype, compression, compresswholefile,
@@ -8396,7 +8505,7 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
         if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 0 or listfoxfiles['ffilelist'][lcfi]['ftype'] == 7):
             with open(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
                 if(not listfoxfiles['ffilelist'][lcfi]['fcontentasfile']):
-                    listfoxfiles['ffilelist'][lcfi]['fcontents'] = BytesIO(
+                    listfoxfiles['ffilelist'][lcfi]['fcontents'] = MkTempFile(
                         listfoxfiles['ffilelist'][lcfi]['fcontents'])
                 listfoxfiles['ffilelist'][lcfi]['fcontents'].seek(0, 0)
                 shutil.copyfileobj(
@@ -8448,7 +8557,7 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
                 if(flinkinfo['ftype'] == 0 or flinkinfo['ftype'] == 7):
                     with open(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
                         if(not flinkinfo['fcontentasfile']):
-                            flinkinfo['fcontents'] = BytesIO(
+                            flinkinfo['fcontents'] = MkTempFile(
                                 flinkinfo['fcontents'])
                         flinkinfo['fcontents'].seek(0, 0)
                         shutil.copyfileobj(flinkinfo['fcontents'], fpc)
@@ -8527,7 +8636,7 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
                 if(flinkinfo['ftype'] == 0 or flinkinfo['ftype'] == 7):
                     with open(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
                         if(not flinkinfo['fcontentasfile']):
-                            flinkinfo['fcontents'] = BytesIO(
+                            flinkinfo['fcontents'] = MkTempFile(
                                 flinkinfo['fcontents'])
                         flinkinfo['fcontents'].seek(0, 0)
                         shutil.copyfileobj(flinkinfo['fcontents'], fpc)
@@ -8605,7 +8714,7 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
 
 
 def UnPackFoxFileString(instr, outdir=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
-    fp = BytesIO(instr)
+    fp = MkTempFile(instr)
     listfoxfiles = UnPackFoxFile(fp, outdir, followlink, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, returnfp)
     return listfoxfiles
 
@@ -8628,57 +8737,57 @@ def FoxFileListFiles(infile, fmttype="auto", seekstart=0, seekend=0, skipchecksu
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
     if(isinstance(infile, dict)):
-        listarchivefiles = infile
+        listfoxfiles = infile
     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 = FoxFileToArray(infile, fmttype, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
-    if(not listarchivefiles):
+        listfoxfiles = FoxFileToArray(infile, fmttype, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
+    if(not listfoxfiles):
         return False
-    lenlist = len(listarchivefiles['ffilelist'])
-    fnumfiles = int(listarchivefiles['fnumfiles'])
+    lenlist = len(listfoxfiles['ffilelist'])
+    fnumfiles = int(listfoxfiles['fnumfiles'])
     lcfi = 0
-    lcfx = int(listarchivefiles['fnumfiles'])
-    if(lenlist > listarchivefiles['fnumfiles'] or lenlist < listarchivefiles['fnumfiles']):
+    lcfx = int(listfoxfiles['fnumfiles'])
+    if(lenlist > listfoxfiles['fnumfiles'] or lenlist < listfoxfiles['fnumfiles']):
         lcfx = int(lenlist)
     else:
-        lcfx = int(listarchivefiles['fnumfiles'])
+        lcfx = int(listfoxfiles['fnumfiles'])
     returnval = {}
     while(lcfi < lcfx):
-        returnval.update({lcfi: listarchivefiles['ffilelist'][lcfi]['fname']})
+        returnval.update({lcfi: listfoxfiles['ffilelist'][lcfi]['fname']})
         if(not verbose):
-            VerbosePrintOut(listarchivefiles['ffilelist'][lcfi]['fname'])
+            VerbosePrintOut(listfoxfiles['ffilelist'][lcfi]['fname'])
         if(verbose):
             permissions = {'access': {'0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': (
                 'r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx')}, 'roles': {0: 'owner', 1: 'group', 2: 'other'}}
-            printfname = listarchivefiles['ffilelist'][lcfi]['fname']
-            if(listarchivefiles['ffilelist'][lcfi]['ftype'] == 1):
-                printfname = listarchivefiles['ffilelist'][lcfi]['fname'] + \
-                    " link to " + listarchivefiles['ffilelist'][lcfi]['flinkname']
-            if(listarchivefiles['ffilelist'][lcfi]['ftype'] == 2):
-                printfname = listarchivefiles['ffilelist'][lcfi]['fname'] + \
-                    " -> " + listarchivefiles['ffilelist'][lcfi]['flinkname']
-            fuprint = listarchivefiles['ffilelist'][lcfi]['funame']
+            printfname = listfoxfiles['ffilelist'][lcfi]['fname']
+            if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 1):
+                printfname = listfoxfiles['ffilelist'][lcfi]['fname'] + \
+                    " link to " + listfoxfiles['ffilelist'][lcfi]['flinkname']
+            if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 2):
+                printfname = listfoxfiles['ffilelist'][lcfi]['fname'] + \
+                    " -> " + listfoxfiles['ffilelist'][lcfi]['flinkname']
+            fuprint = listfoxfiles['ffilelist'][lcfi]['funame']
             if(len(fuprint) <= 0):
-                fuprint = listarchivefiles['ffilelist'][lcfi]['fuid']
-            fgprint = listarchivefiles['ffilelist'][lcfi]['fgname']
+                fuprint = listfoxfiles['ffilelist'][lcfi]['fuid']
+            fgprint = listfoxfiles['ffilelist'][lcfi]['fgname']
             if(len(fgprint) <= 0):
-                fgprint = listarchivefiles['ffilelist'][lcfi]['fgid']
+                fgprint = listfoxfiles['ffilelist'][lcfi]['fgid']
             if(newstyle):
-                VerbosePrintOut(ftype_to_str(listarchivefiles['ffilelist'][lcfi]['ftype']) + "\t" + listarchivefiles['ffilelist'][lcfi]['fcompression'] + "\t" + str(
-                listarchivefiles['ffilelist'][lcfi]['fsize']).rjust(15) + "\t" + printfname)
+                VerbosePrintOut(ftype_to_str(listfoxfiles['ffilelist'][lcfi]['ftype']) + "\t" + listfoxfiles['ffilelist'][lcfi]['fcompression'] + "\t" + str(
+                listfoxfiles['ffilelist'][lcfi]['fsize']).rjust(15) + "\t" + printfname)
             else:
-                VerbosePrintOut(PrintPermissionString(listarchivefiles['ffilelist'][lcfi]['fmode'], listarchivefiles['ffilelist'][lcfi]['ftype']) + " " + str(fuprint) + "/" + str(fgprint) + " " + str(
-                listarchivefiles['ffilelist'][lcfi]['fsize']).rjust(15) + " " + datetime.datetime.utcfromtimestamp(listarchivefiles['ffilelist'][lcfi]['fmtime']).strftime('%Y-%m-%d %H:%M') + " " + printfname)
+                VerbosePrintOut(PrintPermissionString(listfoxfiles['ffilelist'][lcfi]['fmode'], listfoxfiles['ffilelist'][lcfi]['ftype']) + " " + str(fuprint) + "/" + str(fgprint) + " " + str(
+                listfoxfiles['ffilelist'][lcfi]['fsize']).rjust(15) + " " + datetime.datetime.utcfromtimestamp(listfoxfiles['ffilelist'][lcfi]['fmtime']).strftime('%Y-%m-%d %H:%M') + " " + printfname)
         lcfi = lcfi + 1
     if(returnfp):
-        return listarchivefiles['fp']
+        return listfoxfiles['fp']
     else:
         return True
 
 
 def FoxFileStringListFiles(instr, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
-    fp = BytesIO(instr)
+    fp = MkTempFile(instr)
     listfoxfiles = FoxFileListFiles(
         instr, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, newstyle, returnfp)
     return listfoxfiles
@@ -8688,7 +8797,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
     if(infile == "-"):
-        infile = BytesIO()
+        infile = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, infile)
         else:
@@ -8728,7 +8837,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 +8849,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")
@@ -8813,7 +8922,7 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
     if(infile == "-"):
-        infile = BytesIO()
+        infile = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, infile)
         else:
@@ -9209,7 +9318,7 @@ def InFileListFiles(infile, verbose=False, formatspecs=__file_format_multi_dict_
 
 
 def ListDirListFiles(infiles, dirlistfromtxt=False, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, checksumtype=["crc32", "crc32", "crc32"], formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
-    outarray = BytesIO()
+    outarray = MkTempFile()
     packform = PackFoxFile(infiles, outarray, dirlistfromtxt, compression, compresswholefile,
                               compressionlevel, followlink, checksumtype, formatspecs, False, True)
     listfoxfiles = FoxFileListFiles(
@@ -9227,32 +9336,32 @@ def make_empty_archive_file_pointer_neo(fp, fmttype=None, checksumtype='crc32',
     return make_empty_file_pointer_neo(fp, fmttype, checksumtype, formatspecs, encoding)
 
 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)
+    return MakeEmptyFile(outfile, fmttype, "auto", False, None, compressionlistalt, checksumtype, formatspecs, returnfp)
 
 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=__file_format_multi_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], encoding="UTF-8", compression="auto", compression_level=None, returnfp=False):
-    return PackFoxFile(infiles, outfile, False, "auto", compression, False, compression_level, compressionlistalt, False, checksumtypes, [], {}, formatspecs, False, returnfp)
+    return PackArchiveFile(infiles, outfile, False, "auto", compression, False, compression_level, compressionlistalt, False, checksumtypes, [], {}, formatspecs, False, returnfp)
 
 def archive_to_array_neo(infile, formatspecs=__file_format_multi_dict__, listonly=False, skipchecksum=False, uncompress=True, returnfp=False):
-    return FoxFileToArray(infile, "auto", 0, 0, listonly, True, uncompress, skipchecksum, formatspecs, False, returnfp)
+    return ArchiveFileToArray(infile, "auto", 0, 0, listonly, True, uncompress, skipchecksum, formatspecs, False, returnfp)
 
 def unpack_neo(infile, outdir='.', formatspecs=__file_format_multi_dict__, skipchecksum=False, uncompress=True, returnfp=False):
-    return UnPackFoxFile(infile, outdir, False, 0, 0, skipchecksum, formatspecs, True, True, False, False, returnfp)
+    return UnPackArchiveFile(infile, outdir, False, 0, 0, skipchecksum, formatspecs, True, True, False, False, returnfp)
 
 def repack_neo(infile, outfile=None, formatspecs=__file_format_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
-    return RePackFoxFile(infile, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
+    return RePackArchiveFile(infile, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
 
 def archivefilevalidate_neo(infile, formatspecs=__file_format_multi_dict__, verbose=False, return_details=False, returnfp=False):
-    return FoxFileValidate(infile, "auto", formatspecs, False, verbose, returnfp)
+    return ArchiveFileValidate(infile, "auto", formatspecs, False, verbose, returnfp)
 
 def archivefilelistfiles_neo(infile, formatspecs=__file_format_multi_dict__, advanced=False, include_dirs=True, returnfp=False):
-    return FoxFileListFiles(infile, "auto", 0, 0, False, formatspecs, False, True, advanced, returnfp)
+    return ArchiveFileListFiles(infile, "auto", 0, 0, False, formatspecs, False, True, advanced, returnfp)
 
 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 RePackFoxFile(intmp, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
+    return RePackArchiveFile(intmp, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
 
 def download_file_from_ftp_file(url):
     urlparts = urlparse(url)
@@ -9295,7 +9404,7 @@ def download_file_from_ftp_file(url):
     ftp.login(urlparts.username, urlparts.password)
     if(urlparts.scheme == "ftps"):
         ftp.prot_p()
-    ftpfile = BytesIO()
+    ftpfile = MkTempFile()
     ftp.retrbinary("RETR "+urlparts.path, ftpfile.write)
     #ftp.storbinary("STOR "+urlparts.path, ftpfile.write);
     ftp.close()
@@ -9356,7 +9465,7 @@ def upload_file_to_ftp_file(ftpfile, url):
 
 
 def upload_file_to_ftp_string(ftpstring, url):
-    ftpfileo = BytesIO(ftpstring)
+    ftpfileo = MkTempFile(ftpstring)
     ftpfile = upload_file_to_ftp_file(ftpfileo, url)
     ftpfileo.close()
     return ftpfile
@@ -9408,7 +9517,7 @@ def download_file_from_http_file(url, headers=None, usehttp=__use_http_lib__):
         return download_file_from_ftp_file(url)
 
     # Create a temporary file object
-    httpfile = BytesIO()
+    httpfile = MkTempFile()
 
     # 1) Requests branch
     if usehttp == 'requests' and haverequests:
@@ -9516,7 +9625,7 @@ if(haveparamiko):
             log.info("Error With URL "+url)
             return False
         sftp = ssh.open_sftp()
-        sftpfile = BytesIO()
+        sftpfile = MkTempFile()
         sftp.getfo(urlparts.path, sftpfile)
         sftp.close()
         ssh.close()
@@ -9586,7 +9695,7 @@ else:
 
 if(haveparamiko):
     def upload_file_to_sftp_string(sftpstring, url):
-        sftpfileo = BytesIO(sftpstring)
+        sftpfileo = MkTempFile(sftpstring)
         sftpfile = upload_file_to_sftp_files(sftpfileo, url)
         sftpfileo.close()
         return sftpfile
@@ -9632,7 +9741,7 @@ if(havepysftp):
             log.info("Error With URL "+url)
             return False
         sftp = ssh.open_sftp()
-        sftpfile = BytesIO()
+        sftpfile = MkTempFile()
         sftp.getfo(urlparts.path, sftpfile)
         sftp.close()
         ssh.close()
@@ -9699,7 +9808,7 @@ else:
 
 if(havepysftp):
     def upload_file_to_pysftp_string(sftpstring, url):
-        sftpfileo = BytesIO(sftpstring)
+        sftpfileo = MkTempFile(sftpstring)
         sftpfile = upload_file_to_pysftp_file(ftpfileo, url)
         sftpfileo.close()
         return sftpfile
@@ -9774,9 +9883,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 +9909,10 @@ 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__):
+    internetfileo = MkTempFile(ifp)
     fp = CompressOpenFileAlt(
-        BytesIO(ifp), compression, compressionlevel, formatspecs)
+        internetfileo, compression, compressionlevel, compressionuselist, formatspecs)
     if(not foxfileout):
         return False
     fp.seek(0, 0)