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

pycatfile-0.21.0.data/scripts/catneofile.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 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())

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyCatFile
-Version: 0.20.8
+Version: 0.21.0
 Summary: A tar like file format name catfile after unix cat command (concatenate files) .
 Home-page: https://github.com/GameMaker2k/PyCatFile
 Download-URL: https://github.com/GameMaker2k/PyCatFile/archive/master.tar.gz

pycatfile-0.21.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pycatfile.py,sha256=elBSNllKuYMpbyFbaAJPgAQPuMc-XQkQ_ryXJB48bNU,439739
+pycatfile-0.21.0.data/scripts/catfile.py,sha256=eJYvkqx5F5V1CKnxQyLQUMvIBOUZYWF4MAlpvqsjBPc,14020
+pycatfile-0.21.0.data/scripts/catneofile.py,sha256=b0sJBb-o6Rx5TO_dqXnJz3fCf-yPbEul1_6uX2CRS0Q,5128
+pycatfile-0.21.0.data/scripts/neocatfile.py,sha256=YIehBXLtZdFN6_3vrCM3qw1vfAiqJZJWdjOGFStg3D4,7148
+pycatfile-0.21.0.dist-info/licenses/LICENSE,sha256=WM1VWxTUVrQbvEa-LC7cKTaBHXiqSTyYPoJvsZSbd7E,1513
+pycatfile-0.21.0.dist-info/METADATA,sha256=g4mW7KSwek34P3ONlOosBN9vS0Zk515Pdf3F5euv83c,802
+pycatfile-0.21.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pycatfile-0.21.0.dist-info/top_level.txt,sha256=ZnSwEHU_60RLIvmFhsATaAaEYjErDQgUymWwoXZ724c,10
+pycatfile-0.21.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pycatfile-0.21.0.dist-info/RECORD,,

pycatfile.py

@@ -14,7 +14,7 @@
     Copyright 2018-2024 Game Maker 2k - http://intdb.sourceforge.net/
     Copyright 2018-2024 Kazuki Przyborowski - https://github.com/KazukiPrzyborowski
 
-    $FileInfo: pycatfile.py - Last Update: 9/16/2025 Ver. 0.20.8 RC 1 - Author: cooldude2k $
+    $FileInfo: pycatfile.py - Last Update: 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
@@ -391,12 +391,12 @@ __file_format_extension__ = __file_format_multi_dict__[__file_format_default__][
 __file_format_dict__ = __file_format_multi_dict__[__file_format_default__]
 __project__ = __program_name__
 __project_url__ = "https://github.com/GameMaker2k/PyCatFile"
-__version_info__ = (0, 20, 8, "RC 1", 1)
-__version_date_info__ = (2025, 9, 16, "RC 1", 1)
+__version_info__ = (0, 21, 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: a69bd62016afabfda33086a3b227152aaf9e7521 $"
+__revision_id__ = "$Id: b2575bb19f97aab82c71ff7641b170a308e0be5e $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -3636,11 +3636,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)
@@ -3661,10 +3664,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]
@@ -3681,13 +3681,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)
@@ -3708,10 +3711,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]
@@ -5098,11 +5098,14 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         fcsize = format(int(0), 'x').lower()
         fcontents = BytesIO()
         fcencoding = "UTF-8"
-        if ftype in data_types:
+        curcompression = "none"
+        if not followlink and ftype in data_types:
             with open(fname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, False)
-                if(not compresswholefile):
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -5123,10 +5126,7 @@ def PackCatFile(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]
@@ -5143,15 +5143,16 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
-        if(fcompression == "none"):
-            fcompression = ""
-        if(followlink and (ftype == 1 or ftype == 2)):
+        elif followlink and (ftype == 1 or ftype == 2):
             if(not os.path.exists(flinkname)):
                 return False
             flstatinfo = os.stat(flinkname)
             with open(flinkname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                if(not compresswholefile):
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
+                fcencoding = GetFileEncoding(fcontents, False)
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -5172,10 +5173,7 @@ def PackCatFile(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]
@@ -5192,6 +5190,8 @@ def PackCatFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
+        if(fcompression == "none"):
+            fcompression = ""
         fcontents.seek(0, 0)
         ftypehex = format(ftype, 'x').lower()
         tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
@@ -5445,11 +5445,14 @@ def PackCatFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         fcsize = format(int(0), 'x').lower()
         fcontents = BytesIO()
         fcencoding = "UTF-8"
+        curcompression = "none"
         if ftype in data_types:
             fpc = tarfp.extractfile(member)
             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)
@@ -5470,10 +5473,7 @@ def PackCatFileFromTarFile(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]
@@ -5743,10 +5743,13 @@ def PackCatFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
             fgname = ""
         fcontents = BytesIO()
         fcencoding = "UTF-8"
-        if(ftype == 0):
+        curcompression = "none"
+        if ftype == 0:
             fcontents.write(zipfp.read(member.filename))
+            typechecktest = CheckCompressionType(fcontents, closefp=False)
+            fcontents.seek(0, 0)
             fcencoding = GetFileEncoding(fcontents, False)
-            if(not compresswholefile):
+            if(typechecktest is False and not compresswholefile):
                 fcontents.seek(0, 2)
                 ucfsize = fcontents.tell()
                 fcontents.seek(0, 0)
@@ -6057,10 +6060,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)
@@ -6081,10 +6087,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]
@@ -6308,12 +6311,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)
@@ -6334,10 +6340,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]
@@ -8178,10 +8181,13 @@ def RePackCatFile(infile, outfile, fmttype="auto", compression="auto", compressw
         fcontents = listarchivefiles['ffilelist'][reallcfi]['fcontents']
         if(not listarchivefiles['ffilelist'][reallcfi]['fcontentasfile']):
             fcontents = BytesIO(fcontents)
+        typechecktest = CheckCompressionType(fcontents, closefp=False)
+        fcontents.seek(0, 0)
         fcencoding = GetFileEncoding(fcontents, False)
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
-        if(not compresswholefile):
+        curcompression = "none"
+        if typechecktest is False and not compresswholefile:
             fcontents.seek(0, 2)
             ucfsize = fcontents.tell()
             fcontents.seek(0, 0)
@@ -8202,10 +8208,7 @@ def RePackCatFile(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]
@@ -8222,7 +8225,7 @@ def RePackCatFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 fcompression = curcompression
                 fcontents.close()
                 fcontents = cfcontents
-        if(followlink):
+        if followlink:
             if(listarchivefiles['ffilelist'][reallcfi]['ftype'] == 1 or listarchivefiles['ffilelist'][reallcfi]['ftype'] == 2):
                 getflinkpath = listarchivefiles['ffilelist'][reallcfi]['flinkname']
                 flinkid = prelistarchivefiles['filetoid'][getflinkpath]
@@ -8631,7 +8634,7 @@ def CatFileListFiles(infile, fmttype="auto", seekstart=0, seekend=0, skipchecksu
     else:
         if(infile != "-" and not hasattr(infile, "read") and not hasattr(infile, "write") and not (sys.version_info[0] >= 3 and isinstance(infile, bytes))):
             infile = RemoveWindowsPath(infile)
-        listarchivefiles = ArchiveFileToArray(infile, fmttype, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
+        listarchivefiles = CatFileToArray(infile, fmttype, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
     if(not listarchivefiles):
         return False
     lenlist = len(listarchivefiles['ffilelist'])
@@ -9219,37 +9222,37 @@ def ListDirListFiles(infiles, dirlistfromtxt=False, compression="auto", compress
 PyNeoFile compatibility layer
 """
 
-def make_empty_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8'):
+def make_empty_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8'):
     return MakeEmptyFilePointer(fp, fmttype, checksumtype, formatspecs)
 
-def make_empty_archive_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8'):
+def make_empty_archive_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8'):
     return make_empty_file_pointer_neo(fp, fmttype, checksumtype, formatspecs, encoding)
 
-def make_empty_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8', returnfp=False):
+def make_empty_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8', returnfp=False):
     return MakeEmptyFile(outfile, fmttype, "auto", False, None, checksumtype, formatspecs, returnfp)
 
-def make_empty_archive_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8', returnfp=False):
+def make_empty_archive_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8', returnfp=False):
     return make_empty_file_neo(outfile, fmttype, checksumtype, formatspecs, encoding, returnfp)
 
-def pack_neo(infiles, outfile=None, formatspecs=None, checksumtypes=["crc32", "crc32", "crc32", "crc32"], encoding="UTF-8", compression="auto", compression_level=None, returnfp=False):
+def pack_neo(infiles, outfile=None, formatspecs=__file_format_multi_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], encoding="UTF-8", compression="auto", compression_level=None, returnfp=False):
     return PackCatFile(infiles, outfile, False, "auto", compression, False, compression_level, compressionlistalt, False, checksumtypes, [], {}, formatspecs, False, returnfp)
 
-def archive_to_array_neo(infile, formatspecs=None, listonly=False, skipchecksum=False, uncompress=True, returnfp=False):
+def archive_to_array_neo(infile, formatspecs=__file_format_multi_dict__, listonly=False, skipchecksum=False, uncompress=True, returnfp=False):
     return CatFileToArray(infile, "auto", 0, 0, listonly, True, uncompress, skipchecksum, formatspecs, False, returnfp)
 
-def unpack_neo(infile, outdir='.', formatspecs=None, skipchecksum=False, uncompress=True, returnfp=False):
+def unpack_neo(infile, outdir='.', formatspecs=__file_format_multi_dict__, skipchecksum=False, uncompress=True, returnfp=False):
     return UnPackCatFile(infile, outdir, False, 0, 0, skipchecksum, formatspecs, True, True, False, False, returnfp)
 
-def repack_neo(infile, outfile=None, formatspecs=None, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
+def repack_neo(infile, outfile=None, formatspecs=__file_format_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
     return RePackCatFile(infile, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
 
-def archivefilevalidate_neo(infile, formatspecs=None, verbose=False, return_details=False, returnfp=False):
+def archivefilevalidate_neo(infile, formatspecs=__file_format_multi_dict__, verbose=False, return_details=False, returnfp=False):
     return CatFileValidate(infile, "auto", formatspecs, False, verbose, returnfp)
 
-def archivefilelistfiles_neo(infile, formatspecs=None, advanced=False, include_dirs=True, returnfp=False):
+def archivefilelistfiles_neo(infile, formatspecs=__file_format_multi_dict__, advanced=False, include_dirs=True, returnfp=False):
     return CatFileListFiles(infile, "auto", 0, 0, False, formatspecs, False, True, advanced, returnfp)
 
-def convert_foreign_to_neo(infile, outfile=None, formatspecs=None, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
+def convert_foreign_to_neo(infile, outfile=None, formatspecs=__file_format_multi_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
     intmp = InFileToArray(infile, 0, 0, False, True, False, formatspecs, False, False)
     return RePackCatFile(intmp, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
 

pycatfile-0.20.8.dist-info/RECORD

@@ -1,9 +0,0 @@
-pycatfile.py,sha256=wN6D39Pz0O3TaOrjsiXYFzDosPDtQKcmNFgyrL7Iuus,439087
-pycatfile-0.20.8.data/scripts/catfile.py,sha256=eJYvkqx5F5V1CKnxQyLQUMvIBOUZYWF4MAlpvqsjBPc,14020
-pycatfile-0.20.8.data/scripts/neocatfile.py,sha256=YIehBXLtZdFN6_3vrCM3qw1vfAiqJZJWdjOGFStg3D4,7148
-pycatfile-0.20.8.dist-info/licenses/LICENSE,sha256=WM1VWxTUVrQbvEa-LC7cKTaBHXiqSTyYPoJvsZSbd7E,1513
-pycatfile-0.20.8.dist-info/METADATA,sha256=FkmLEj0I0lJ-kNH1BgsDlSFnOI8nT8sGvJAnUMLT6O8,802
-pycatfile-0.20.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pycatfile-0.20.8.dist-info/top_level.txt,sha256=ZnSwEHU_60RLIvmFhsATaAaEYjErDQgUymWwoXZ724c,10
-pycatfile-0.20.8.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pycatfile-0.20.8.dist-info/RECORD,,