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

pyfoxfile-0.21.0.data/scripts/foxneofile.py

@@ -0,0 +1,130 @@
+#!python
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import sys, os, io, argparse
+
+try:
+    import pyfoxfile as P  # core must provide *_neo functions
+except Exception as e:
+    sys.stderr.write("Failed to import core module 'pyfoxfile': %s\n" % (e,))
+    sys.exit(2)
+
+
+def _expand_combined_short_opts(argv):
+    out = [argv[0]]
+    i = 1
+    while i < len(argv):
+        a = argv[i]
+        if a.startswith("--") or not (a.startswith("-") and len(a) > 2):
+            out.append(a); i += 1; continue
+        for ch in a[1:]:
+            out.append("-" + ch)
+        i += 1
+    return out
+
+
+def main():
+    argv = _expand_combined_short_opts(sys.argv)
+
+    p = argparse.ArgumentParser(
+        description="PyNeoFile CLI (uses pyfoxfile core)")
+    g = p.add_mutually_exclusive_group(required=True)
+    g.add_argument("-l", "--list", action="store_true", help="List archive")
+    g.add_argument("-e", "--extract", action="store_true", help="Extract archive")
+    g.add_argument("-c", "--create", action="store_true", help="Create archive from path")
+    g.add_argument("-r", "--repack", action="store_true", help="Repack (recompress) an archive")
+    g.add_argument("-E", "--empty", action="store_true", help="Create an empty archive")
+
+    p.add_argument("-i", "--input", help="Input file/path", nargs="*")
+    p.add_argument("-o", "--output", help="Output file/dir (or '-' for stdout)")
+    p.add_argument("-d", "--verbose", action="store_true", help="Verbose/detailed listing")
+    p.add_argument("-P", "--compression", default="auto", help="Compression algo (auto, none, zlib, gzip, bz2, lzma)")
+    p.add_argument("-L", "--level", type=int, default=None, help="Compression level/preset")
+    p.add_argument("--checksum", default="crc32", help="Checksum type for header/content/json (default: crc32)")
+
+    args = p.parse_args(argv[1:])
+
+    src = None
+    if args.input:
+        if isinstance(args.input, list) and len(args.input) == 1:
+            src = args.input[0]
+        elif isinstance(args.input, list) and len(args.input) > 1:
+            src = args.input[0]
+        else:
+            src = args.input
+
+    if args.empty:
+        dst = args.output or "-"
+        blob_or_true = P.make_empty_file_neo(dst, fmttype="auto", checksumtype=args.checksum, encoding="UTF-8", returnfp=False)
+        if dst in (None, "-"):
+            data = blob_or_true if isinstance(blob_or_true, (bytes, bytearray)) else b""
+            if hasattr(sys.stdout, "buffer"):
+                sys.stdout.buffer.write(data)
+            else:
+                sys.stdout.write(data.decode("latin1"))
+        return 0
+
+    if args.list:
+        if not src:
+            p.error("list requires -i <archive>")
+        P.archivefilelistfiles_neo(src, advanced=args.verbose, include_dirs=True)
+        return 0
+
+    if args.extract:
+        if not src:
+            p.error("extract requires -i <archive>")
+        outdir = args.output or "."
+        ok = P.unpack_neo(src, outdir, skipchecksum=False, uncompress=True)
+        return 0 if ok else 1
+
+    if args.create:
+        if not src:
+            p.error("create requires -i <path>")
+        if args.verbose:
+            walkroot = src
+            if os.path.isdir(walkroot):
+                print(walkroot)
+                for root, dirs, files in os.walk(walkroot):
+                    relroot = root if root.startswith("./") else "./" + root.replace("\\", "/")
+                    if root != walkroot:
+                        print(relroot)
+                    for name in sorted(files):
+                        path = os.path.join(root, name).replace("\\", "/")
+                        if not path.startswith("./"):
+                            path = "./" + path
+                        print(path)
+            else:
+                path = src if src.startswith("./") else "./" + src
+                print(path)
+
+        outpath = args.output or "-"
+        ok = P.pack_neo(src, outpath, checksumtypes=(args.checksum,args.checksum,args.checksum,args.checksum),
+                        encoding="UTF-8", compression=args.compression, compression_level=args.level)
+        if outpath in (None, "-") and isinstance(ok, (bytes, bytearray)):
+            if hasattr(sys.stdout, "buffer"):
+                sys.stdout.buffer.write(ok)
+            else:
+                sys.stdout.write(ok.decode("latin1"))
+            return 0
+        return 0 if ok else 1
+
+    if args.repack:
+        if not src:
+            p.error("repack requires -i <archive>")
+        outpath = args.output or "-"
+        ok = P.repack_neo(src, outpath, checksumtypes=(args.checksum,args.checksum,args.checksum,args.checksum),
+                          compression=args.compression, compression_level=args.level)
+        if outpath in (None, "-") and isinstance(ok, (bytes, bytearray)):
+            if hasattr(sys.stdout, "buffer"):
+                sys.stdout.buffer.write(ok)
+            else:
+                sys.stdout.write(ok.decode("latin1"))
+            return 0
+        return 0 if ok else 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

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

pyfoxfile-0.21.0.dist-info/RECORD

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

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/16/2025 Ver. 0.20.8 RC 1 - Author: cooldude2k $
+    $FileInfo: pyfoxfile.py - Last Update: 9/17/2025 Ver. 0.21.0 RC 1 - Author: cooldude2k $
 '''
 
 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
@@ -370,6 +370,10 @@ if(__include_defaults__):
         __file_format_multi_dict__.update( { 'きつねファイル': {'format_name': "KitsuneFairu", 'format_magic': "きつねファイル", 'format_len': 21, 'format_hex': "e3818de381a4e381ade38395e382a1e382a4e383ab", 'format_delimiter': "\x00", 'format_ver': "001", 'new_style': True, 'use_advanced_list': True, 'use_alt_inode': False, 'format_extension': ".きつね" } } )
     if("狐ファイル" not in __file_format_multi_dict__):
         __file_format_multi_dict__.update( { '狐ファイル': {'format_name': "KitsuneFairu", 'format_magic': "狐ファイル", 'format_len': 15, 'format_hex': "e78b90e38395e382a1e382a4e383ab", 'format_delimiter': "\x00", 'format_ver': "001", 'new_style': True, 'use_advanced_list': True, 'use_alt_inode': False, 'format_extension': ".狐" } } )
+    if("狐狸文件" not in __file_format_multi_dict__):
+        __file_format_multi_dict__.update( { '狐狸文件': {'format_name': "HúlíWénjiàn", 'format_magic': "狐狸文件", 'format_len': 12, 'format_hex': "ec97acec9ab0ed8c8cec9dbc", 'format_delimiter': "\x00", 'format_ver': "001", 'new_style': True, 'use_advanced_list': True, 'use_alt_inode': False, 'format_extension': ".狐狸" } } )
+    if("여우파일" not in __file_format_multi_dict__):
+        __file_format_multi_dict__.update( { '여우파일': {'format_name': "YeouPa-il", 'format_magic': "여우파일", 'format_len': 12, 'format_hex': "ec97acec9ab0ed8c8cec9dbc", 'format_delimiter': "\x00", 'format_ver': "001", 'new_style': True, 'use_advanced_list': True, 'use_alt_inode': False, 'format_extension': ".여우" } } )
 if(__file_format_default__ not in __file_format_multi_dict__):
     __file_format_default__ = next(iter(__file_format_multi_dict__))
 __file_format_name__ = __file_format_multi_dict__[__file_format_default__]['format_name']
@@ -385,12 +389,12 @@ __file_format_extension__ = __file_format_multi_dict__[__file_format_default__][
 __file_format_dict__ = __file_format_multi_dict__[__file_format_default__]
 __project__ = __program_name__
 __project_url__ = "https://github.com/GameMaker2k/PyFoxFile"
-__version_info__ = (0, 20, 8, "RC 1", 1)
-__version_date_info__ = (2025, 9, 16, "RC 1", 1)
+__version_info__ = (0, 21, 0, "RC 1", 1)
+__version_date_info__ = (2025, 9, 17, "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: c24bcebed9f90311395ef150d337a5669849d131 $"
+__revision_id__ = "$Id: 6208d3cb66a43a7e1047211a926f92f6aecfff08 $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -3630,11 +3634,14 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
         fcontents = BytesIO()
         chunk_size = 1024
         fcencoding = "UTF-8"
-        if ftype in data_types:
+        curcompression = "none"
+        if not followlink and ftype in data_types:
             with open(fname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, False)
-                if(not compresswholefile):
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -3655,10 +3662,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                                 ilcsize.append(cfcontents.tell())
                                 cfcontents.close()
                             else:
-                                try:
-                                    ilcsize.append(sys.maxint)
-                                except AttributeError:
-                                    ilcsize.append(sys.maxsize)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -3675,13 +3679,16 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                         fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
-        if(followlink and (ftype == 1 or ftype == 2)):
+        elif followlink and (ftype == 1 or ftype == 2):
             if(not os.path.exists(flinkname)):
                 return False
             flstatinfo = os.stat(flinkname)
             with open(flinkname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                if(not compresswholefile):
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
+                fcencoding = GetFileEncoding(fcontents, False)
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -3702,10 +3709,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                                 ilcsize.append(cfcontents.tell())
                                 cfcontents.close()
                             else:
-                                try:
-                                    ilcsize.append(sys.maxint)
-                                except AttributeError:
-                                    ilcsize.append(sys.maxsize)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -5092,11 +5096,14 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         fcsize = format(int(0), 'x').lower()
         fcontents = BytesIO()
         fcencoding = "UTF-8"
-        if ftype in data_types:
+        curcompression = "none"
+        if not followlink and ftype in data_types:
             with open(fname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, False)
-                if(not compresswholefile):
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -5117,10 +5124,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                                 ilcsize.append(cfcontents.tell())
                                 cfcontents.close()
                             else:
-                                try:
-                                    ilcsize.append(sys.maxint)
-                                except AttributeError:
-                                    ilcsize.append(sys.maxsize)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -5137,15 +5141,16 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
-        if(fcompression == "none"):
-            fcompression = ""
-        if(followlink and (ftype == 1 or ftype == 2)):
+        elif followlink and (ftype == 1 or ftype == 2):
             if(not os.path.exists(flinkname)):
                 return False
             flstatinfo = os.stat(flinkname)
             with open(flinkname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                if(not compresswholefile):
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
+                fcencoding = GetFileEncoding(fcontents, False)
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -5166,10 +5171,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                                 ilcsize.append(cfcontents.tell())
                                 cfcontents.close()
                             else:
-                                try:
-                                    ilcsize.append(sys.maxint)
-                                except AttributeError:
-                                    ilcsize.append(sys.maxsize)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -5186,6 +5188,8 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
+        if(fcompression == "none"):
+            fcompression = ""
         fcontents.seek(0, 0)
         ftypehex = format(ftype, 'x').lower()
         tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
@@ -5439,11 +5443,14 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         fcsize = format(int(0), 'x').lower()
         fcontents = BytesIO()
         fcencoding = "UTF-8"
+        curcompression = "none"
         if ftype in data_types:
             fpc = tarfp.extractfile(member)
             shutil.copyfileobj(fpc, fcontents)
+            typechecktest = CheckCompressionType(fcontents, closefp=False)
+            fcontents.seek(0, 0)
             fcencoding = GetFileEncoding(fcontents, False)
-            if(not compresswholefile):
+            if(typechecktest is False and not compresswholefile):
                 fcontents.seek(0, 2)
                 ucfsize = fcontents.tell()
                 fcontents.seek(0, 0)
@@ -5464,10 +5471,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                             ilcsize.append(cfcontents.tell())
                             cfcontents.close()
                         else:
-                            try:
-                                ilcsize.append(sys.maxint)
-                            except AttributeError:
-                                ilcsize.append(sys.maxsize)
+                            ilcsize.append(float("inf"))
                         ilmin = ilmin + 1
                     ilcmin = ilcsize.index(min(ilcsize))
                     curcompression = compressionuselist[ilcmin]
@@ -5737,10 +5741,13 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
             fgname = ""
         fcontents = BytesIO()
         fcencoding = "UTF-8"
-        if(ftype == 0):
+        curcompression = "none"
+        if ftype == 0:
             fcontents.write(zipfp.read(member.filename))
+            typechecktest = CheckCompressionType(fcontents, closefp=False)
+            fcontents.seek(0, 0)
             fcencoding = GetFileEncoding(fcontents, False)
-            if(not compresswholefile):
+            if(typechecktest is False and not compresswholefile):
                 fcontents.seek(0, 2)
                 ucfsize = fcontents.tell()
                 fcontents.seek(0, 0)
@@ -6051,10 +6058,13 @@ if(rarfile_support):
                 fgname = ""
             fcontents = BytesIO()
             fcencoding = "UTF-8"
-            if(ftype == 0):
+            curcompression = "none"
+            if ftype == 0:
                 fcontents.write(rarfp.read(member.filename))
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, False)
-                if(not compresswholefile):
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -6075,10 +6085,7 @@ if(rarfile_support):
                                 ilcsize.append(cfcontents.tell())
                                 cfcontents.close()
                             else:
-                                try:
-                                    ilcsize.append(sys.maxint)
-                                except AttributeError:
-                                    ilcsize.append(sys.maxsize)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -6302,12 +6309,15 @@ if(py7zr_support):
                 fgname = ""
             fcontents = BytesIO()
             fcencoding = "UTF-8"
-            if(ftype == 0):
+             curcompression = "none"
+            if ftype == 0:
                 fcontents.write(file_content[member.filename].read())
+                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(not compresswholefile):
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -6328,10 +6338,7 @@ if(py7zr_support):
                                 ilcsize.append(cfcontents.tell())
                                 cfcontents.close()
                             else:
-                                try:
-                                    ilcsize.append(sys.maxint)
-                                except AttributeError:
-                                    ilcsize.append(sys.maxsize)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -8172,10 +8179,13 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
         fcontents = listfoxfiles['ffilelist'][reallcfi]['fcontents']
         if(not listfoxfiles['ffilelist'][reallcfi]['fcontentasfile']):
             fcontents = BytesIO(fcontents)
+        typechecktest = CheckCompressionType(fcontents, closefp=False)
+        fcontents.seek(0, 0)
         fcencoding = GetFileEncoding(fcontents, False)
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
-        if(not compresswholefile):
+        curcompression = "none"
+        if typechecktest is False and not compresswholefile:
             fcontents.seek(0, 2)
             ucfsize = fcontents.tell()
             fcontents.seek(0, 0)
@@ -8196,10 +8206,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                         ilcsize.append(cfcontents.tell())
                         cfcontents.close()
                     else:
-                        try:
-                            ilcsize.append(sys.maxint)
-                        except AttributeError:
-                            ilcsize.append(sys.maxsize)
+                        ilcsize.append(float("inf"))
                     ilmin = ilmin + 1
                 ilcmin = ilcsize.index(min(ilcsize))
                 curcompression = compressionuselist[ilcmin]
@@ -8216,11 +8223,11 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 fcompression = curcompression
                 fcontents.close()
                 fcontents = cfcontents
-        if(followlink):
-            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]
+        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]
                 fheadersize = format(
                     int(flinkinfo['fheadersize']), 'x').lower()
                 fsize = format(int(flinkinfo['fsize']), 'x').lower()
@@ -8257,7 +8264,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 ftypehex = format(flinkinfo['ftype'], 'x').lower()
         else:
             ftypehex = format(
-                listfoxfiles['ffilelist'][reallcfi]['ftype'], 'x').lower()
+                listarchivefiles['ffilelist'][reallcfi]['ftype'], 'x').lower()
         fcurfid = format(curfid, 'x').lower()
         if(not followlink and finode != 0):
             if(listfoxfiles['ffilelist'][reallcfi]['ftype'] != 1):
@@ -8625,7 +8632,7 @@ def FoxFileListFiles(infile, fmttype="auto", seekstart=0, seekend=0, skipchecksu
     else:
         if(infile != "-" and not hasattr(infile, "read") and not hasattr(infile, "write") and not (sys.version_info[0] >= 3 and isinstance(infile, bytes))):
             infile = RemoveWindowsPath(infile)
-        listarchivefiles = ArchiveFileToArray(infile, fmttype, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
+        listarchivefiles = FoxFileToArray(infile, fmttype, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
     if(not listarchivefiles):
         return False
     lenlist = len(listarchivefiles['ffilelist'])
@@ -9213,37 +9220,37 @@ def ListDirListFiles(infiles, dirlistfromtxt=False, compression="auto", compress
 PyNeoFile compatibility layer
 """
 
-def make_empty_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8'):
+def make_empty_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8'):
     return MakeEmptyFilePointer(fp, fmttype, checksumtype, formatspecs)
 
-def make_empty_archive_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8'):
+def make_empty_archive_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8'):
     return make_empty_file_pointer_neo(fp, fmttype, checksumtype, formatspecs, encoding)
 
-def make_empty_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8', returnfp=False):
+def make_empty_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8', returnfp=False):
     return MakeEmptyFile(outfile, fmttype, "auto", False, None, checksumtype, formatspecs, returnfp)
 
-def make_empty_archive_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8', returnfp=False):
+def make_empty_archive_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8', returnfp=False):
     return make_empty_file_neo(outfile, fmttype, checksumtype, formatspecs, encoding, returnfp)
 
-def pack_neo(infiles, outfile=None, formatspecs=None, checksumtypes=["crc32", "crc32", "crc32", "crc32"], encoding="UTF-8", compression="auto", compression_level=None, returnfp=False):
+def pack_neo(infiles, outfile=None, formatspecs=__file_format_multi_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], encoding="UTF-8", compression="auto", compression_level=None, returnfp=False):
     return PackFoxFile(infiles, outfile, False, "auto", compression, False, compression_level, compressionlistalt, False, checksumtypes, [], {}, formatspecs, False, returnfp)
 
-def archive_to_array_neo(infile, formatspecs=None, listonly=False, skipchecksum=False, uncompress=True, returnfp=False):
+def archive_to_array_neo(infile, formatspecs=__file_format_multi_dict__, listonly=False, skipchecksum=False, uncompress=True, returnfp=False):
     return FoxFileToArray(infile, "auto", 0, 0, listonly, True, uncompress, skipchecksum, formatspecs, False, returnfp)
 
-def unpack_neo(infile, outdir='.', formatspecs=None, skipchecksum=False, uncompress=True, returnfp=False):
+def unpack_neo(infile, outdir='.', formatspecs=__file_format_multi_dict__, skipchecksum=False, uncompress=True, returnfp=False):
     return UnPackFoxFile(infile, outdir, False, 0, 0, skipchecksum, formatspecs, True, True, False, False, returnfp)
 
-def repack_neo(infile, outfile=None, formatspecs=None, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
+def repack_neo(infile, outfile=None, formatspecs=__file_format_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
     return RePackFoxFile(infile, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
 
-def archivefilevalidate_neo(infile, formatspecs=None, verbose=False, return_details=False, returnfp=False):
+def archivefilevalidate_neo(infile, formatspecs=__file_format_multi_dict__, verbose=False, return_details=False, returnfp=False):
     return FoxFileValidate(infile, "auto", formatspecs, False, verbose, returnfp)
 
-def archivefilelistfiles_neo(infile, formatspecs=None, advanced=False, include_dirs=True, returnfp=False):
+def archivefilelistfiles_neo(infile, formatspecs=__file_format_multi_dict__, advanced=False, include_dirs=True, returnfp=False):
     return FoxFileListFiles(infile, "auto", 0, 0, False, formatspecs, False, True, advanced, returnfp)
 
-def convert_foreign_to_neo(infile, outfile=None, formatspecs=None, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
+def convert_foreign_to_neo(infile, outfile=None, formatspecs=__file_format_multi_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
     intmp = InFileToArray(infile, 0, 0, False, True, False, formatspecs, False, False)
     return RePackFoxFile(intmp, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
 

pyfoxfile-0.20.8.dist-info/RECORD

@@ -1,9 +0,0 @@
-pyfoxfile.py,sha256=tl_qySFcwKLuUaH7m2VGn0QUYbxnjw4hCE1BIRMOR6s,437205
-pyfoxfile-0.20.8.data/scripts/foxfile.py,sha256=jVbflioQQRu6dy85bt8QW9OfXr5rzfmmQ75qM-Q31u4,13994
-pyfoxfile-0.20.8.data/scripts/neofoxfile.py,sha256=5_A2OgXuV7Yj0SAb5F2PysPneIBrqfuM8REjClRquN4,7113
-pyfoxfile-0.20.8.dist-info/licenses/LICENSE,sha256=WM1VWxTUVrQbvEa-LC7cKTaBHXiqSTyYPoJvsZSbd7E,1513
-pyfoxfile-0.20.8.dist-info/METADATA,sha256=_dImShhjCo_SXSLkkeKP7eCgZ3VNq_ijMY-w6t-E10E,715
-pyfoxfile-0.20.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyfoxfile-0.20.8.dist-info/top_level.txt,sha256=VTOkpGfBWHNht7FKfnbccd32n_Jgk8Df5NKKfzaliTc,10
-pyfoxfile-0.20.8.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pyfoxfile-0.20.8.dist-info/RECORD,,