PyArchiveFile 0.20.8__tar.gz → 0.21.0__tar.gz

{pyarchivefile-0.20.8 → pyarchivefile-0.21.0}/PKG-INFO

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

{pyarchivefile-0.20.8 → pyarchivefile-0.21.0}/PyArchiveFile.egg-info/PKG-INFO

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

{pyarchivefile-0.20.8 → pyarchivefile-0.21.0}/PyArchiveFile.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE
 README.md
 archivefile.py
+archiveneofile.py
 neoarchivefile.py
 pyarchivefile.py
 pyproject.toml

pyarchivefile-0.21.0/archiveneofile.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import sys, os, io, argparse
+
+try:
+    import pycatfile as P  # core must provide *_neo functions
+except Exception as e:
+    sys.stderr.write("Failed to import core module 'pycatfile': %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 pycatfile 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())

{pyarchivefile-0.20.8 → pyarchivefile-0.21.0}/pyarchivefile.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: pyarchivefile.py - Last Update: 9/16/2025 Ver. 0.20.8 RC 1 - Author: cooldude2k $
+    $FileInfo: pyarchivefile.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
@@ -379,12 +379,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/PyArchiveFile"
-__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: a7748608b447590b70022b5ee2ae2f98c891c535 $"
+__revision_id__ = "$Id: 40a5a37977e6917976fb60e9cd8b0fbd879c8bce $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -3624,11 +3624,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)
@@ -3649,10 +3652,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]
@@ -3669,13 +3669,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)
@@ -3696,10 +3699,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]
@@ -5086,11 +5086,14 @@ def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", comp
         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)
@@ -5111,10 +5114,7 @@ def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", comp
                                 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]
@@ -5131,15 +5131,16 @@ def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", comp
                         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)
@@ -5160,10 +5161,7 @@ def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", comp
                                 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]
@@ -5180,6 +5178,8 @@ def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", comp
                         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,
@@ -5433,11 +5433,14 @@ def PackArchiveFileFromTarFile(infile, outfile, fmttype="auto", compression="aut
         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)
@@ -5458,10 +5461,7 @@ def PackArchiveFileFromTarFile(infile, outfile, fmttype="auto", compression="aut
                             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]
@@ -5731,10 +5731,13 @@ def PackArchiveFileFromZipFile(infile, outfile, fmttype="auto", compression="aut
             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)
@@ -6045,10 +6048,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)
@@ -6069,10 +6075,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]
@@ -6296,12 +6299,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)
@@ -6322,10 +6328,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]
@@ -8166,10 +8169,13 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
         fcontents = listarchivefiles['ffilelist'][reallcfi]['fcontents']
         if(not listarchivefiles['ffilelist'][reallcfi]['fcontentasfile']):
             fcontents = BytesIO(fcontents)
+        typechecktest = CheckCompressionType(fcontents, closefp=False)
+        fcontents.seek(0, 0)
         fcencoding = GetFileEncoding(fcontents, False)
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
-        if(not compresswholefile):
+        curcompression = "none"
+        if typechecktest is False and not compresswholefile:
             fcontents.seek(0, 2)
             ucfsize = fcontents.tell()
             fcontents.seek(0, 0)
@@ -8190,10 +8196,7 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
                         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]
@@ -8210,7 +8213,7 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
                 fcompression = curcompression
                 fcontents.close()
                 fcontents = cfcontents
-        if(followlink):
+        if followlink:
             if(listarchivefiles['ffilelist'][reallcfi]['ftype'] == 1 or listarchivefiles['ffilelist'][reallcfi]['ftype'] == 2):
                 getflinkpath = listarchivefiles['ffilelist'][reallcfi]['flinkname']
                 flinkid = prelistarchivefiles['filetoid'][getflinkpath]
@@ -9207,37 +9210,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 PackArchiveFile(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 ArchiveFileToArray(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 UnPackArchiveFile(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 RePackArchiveFile(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 ArchiveFileValidate(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 ArchiveFileListFiles(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 RePackArchiveFile(intmp, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
 

{pyarchivefile-0.20.8 → pyarchivefile-0.21.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
     name = "PyArchiveFile"
-    version = "0.20.8"
+    version = "0.21.0"
     readme = "README.md"
     license = { text = "BSD-3-Clause" }
     keywords = []

{pyarchivefile-0.20.8 → pyarchivefile-0.21.0}/setup.py

@@ -13,7 +13,7 @@
     Copyright 2016-2024 Game Maker 2k - http://intdb.sourceforge.net/
     Copyright 2016-2024 Kazuki Przyborowski - https://github.com/KazukiPrzyborowski
 
-    $FileInfo: setup.py - Last Update: 3/7/2025 Ver. 0.19.0 RC 1 - Author: cooldude2k $
+    $FileInfo: setup.py - Last Update: 9/17/2025 Ver. 0.21.0 RC 1 - Author: cooldude2k $
 '''
 
 import os
@@ -79,7 +79,7 @@ pymodule[
 pymodule['platforms'] = 'OS Independent'
 pymodule['zipsafe'] = True
 pymodule['pymodules'] = ['pyarchivefile']
-pymodule['scripts'] = ['archivefile.py', 'neoarchivefile.py']
+pymodule['scripts'] = ['archivefile.py', 'neoarchivefile.py', 'archiveneofile.py']
 pymodule['classifiers'] = [
     'Development Status :: 5 - Production/Stable',
     'Intended Audience :: Developers',