Add files via upload

Author: Kazuki Suzuki

neofile.ini

@@ -0,0 +1,9 @@
+[config]
+default = PyNeoFile
+
+[PyNeoFile]
+magic = PyNeoFile
+ver = 001
+delimiter = \x00
+newstyle = true
+extension = .neo

neofile.py

@@ -5,82 +5,32 @@
 from __future__ import absolute_import, division, print_function, unicode_literals
 
 """
-neofile.py
-A lightweight CLI re-creation of archivefile.py that uses the *alt* implementation
-(pyneofile) you asked for, including:
- - INI-based format defaults (auto-fallback)
- - stdlib compression with size-based "auto" (zlib/gzip/bz2, xz on Py3 when available)
- - robust checksums (CRC-32 padded), JSON/header/content verification
- - Python 2 and 3 compatibility
- - Optional conversion from ZIP/TAR (stdlib), and **RAR/7z** when extra libs are installed:
-      * RAR:   pip install rarfile
-      * 7z:    pip install py7zr
-
-Operations:
-  -c / --create    pack files/dirs into an archive
-  -e / --extract   extract an archive
-  -r / --repack    repack (optionally change compression)
-  -l / --list      list entries (fast, header-only)
-  -v / --validate  validate checksums
-
-Convert support:
-  Use -t/--convert with --create/--repack/--list/--validate to convert a foreign archive
-  (zip/tar are stdlib; rar/7z need optional libs) into the alt ArchiveFile format first.
+neofile.py — CLI for the PyNeoFile format (.neo).
+Uses the pyneofile wrappers (which call into pyneoarc_alt) and prefers pyneofile.ini.
+Supports converting from zip/tar (stdlib), and rar/7z when optional libs are installed.
 """
 
-import os
-import sys
-import argparse
-import tempfile
+import os, sys, argparse, tempfile
+import pyneofile as N
 
-# Graceful SIGPIPE on non-Windows
-if os.name != 'nt':
-    try:
-        import signal
-        if hasattr(signal, 'SIGPIPE'):
-            signal.signal(signal.SIGPIPE, signal.SIG_DFL)
-    except Exception:
-        pass
-
-# Import alt core
-try:
-    import pyneofile as A
-except Exception as e:
-    sys.stderr.write("Failed to import pyneofile: %s\n" % (e,))
-    sys.exit(2)
-
-__program_name__ = "neofile"
-__version__ = "0.2.0"
+__program_name__ = "pyneofile"
+__version__ = "0.1.0"
 
 def _build_formatspecs_from_args(args):
-    """Create a formatspecs dict or return None to use INI auto-fallback."""
+    # Allow explicit override; otherwise let wrappers auto-load pyneofile.ini
     if args.format is None or args.format.lower() == "auto":
-        return None  # let alt core load INI or defaults
-    magic = args.format
-    ver   = args.formatver if args.formatver is not None else "001"
-    delim = args.delimiter if args.delimiter is not None else "\x00"
+        return None
     return {
-        "format_name": magic,
-        "format_magic": magic,
-        "format_ver": ver,                 # alt core keeps digits as-is
-        "format_delimiter": delim,
+        "format_name": args.format,
+        "format_magic": args.format,
+        "format_ver": (args.formatver or "001"),
+        "format_delimiter": (args.delimiter or "\x00"),
         "new_style": True,
     }
 
-def _read_listfile(path):
-    items = []
-    with open(path, 'r') as f:
-        for line in f:
-            s = line.strip()
-            if not s or s.startswith('#'):
-                continue
-            items.append(s)
-    return items
-
 def _convert_or_fail(infile, outpath, formatspecs, checksum, compression, level):
-    """Call core convert function and show friendly messages for missing deps."""
     try:
-        A.convert_foreign_to_alt(infile, outpath, formatspecs=formatspecs,
+        N.convert_foreign_to_neo(infile, outpath, formatspecs=formatspecs,
                                  checksumtypes=(checksum, checksum, checksum),
                                  compression=compression, compression_level=level)
         return True
@@ -93,148 +43,107 @@ def _convert_or_fail(infile, outpath, formatspecs, checksum, compression, level)
         else:
             sys.stderr.write("convert error: %s\n" % msg)
         return False
-    except ValueError as e:
-        # Unsupported format (not zip/tar/rar/7z)
-        sys.stderr.write("convert error: %s\n" % e)
-        return False
     except Exception as e:
-        sys.stderr.write("unexpected convert error: %s\n" % e)
+        sys.stderr.write("convert error: %s\n" % e)
         return False
 
 def main(argv=None):
-    p = argparse.ArgumentParser(description="Manipulate ArchiveFile (alt) archives.", conflict_handler="resolve", add_help=True)
-
-    p.add_argument("-V", "--version", action="version", version=__program_name__ + " " + __version__)
-
-    # IO
-    p.add_argument("-i", "--input", nargs="+", required=True, help="Input file(s) or archive file.")
-    p.add_argument("-o", "--output", default=None, help="Output file or directory.")
+    p = argparse.ArgumentParser(description="PyNeoFile (.neo) archiver", add_help=True)
+    p.add_argument("-V","--version", action="version", version=__program_name__ + " " + __version__)
 
-    # Ops
-    p.add_argument("-c", "--create", action="store_true", help="Create an archive from input files/dirs.")
-    p.add_argument("-e", "--extract", action="store_true", help="Extract an archive to --output (directory).")
-    p.add_argument("-r", "--repack", action="store_true", help="Repack an existing archive (can change compression).")
-    p.add_argument("-l", "--list", action="store_true", help="List archive entries.")
-    p.add_argument("-v", "--validate", action="store_true", help="Validate archive checksums.")
-    p.add_argument("-t", "--convert", action="store_true", help="Treat input as foreign (zip/tar/rar/7z) and convert to ArchiveFile first.")
+    p.add_argument("-i","--input", nargs="+", required=True, help="Input files/dirs or archive file")
+    p.add_argument("-o","--output", default=None, help="Output file or directory")
 
-    # Format & delimiter
-    p.add_argument("-F", "--format", default="auto", help="Format magic to use (or 'auto' to read INI).")
-    p.add_argument("-D", "--delimiter", default=None, help="Delimiter to use when --format is not 'auto'.")
-    p.add_argument("-m", "--formatver", default=None, help="Format version digits (e.g. 001).")
+    p.add_argument("-c","--create", action="store_true", help="Create a .neo archive from inputs")
+    p.add_argument("-e","--extract", action="store_true", help="Extract an archive to --output")
+    p.add_argument("-r","--repack", action="store_true", help="Repack an archive (change compression)")
+    p.add_argument("-l","--list", action="store_true", help="List entries")
+    p.add_argument("-v","--validate", action="store_true", help="Validate checksums")
+    p.add_argument("-t","--convert", action="store_true", help="Convert zip/tar/rar/7z → .neo first")
 
-    # Compression
-    p.add_argument("-P", "--compression", default="auto", help="Compression: none|zlib|gzip|bz2|xz|auto")
-    p.add_argument("-L", "--level", default=None, help="Compression level/preset (int).")
-    p.add_argument("-W", "--wholefile", action="store_true", help="(Ignored; CLI compatibility).")
+    p.add_argument("-F","--format", default="auto", help="Format magic (default 'auto' via pyneofile.ini)")
+    p.add_argument("-D","--delimiter", default=None, help="Delimiter (when not using 'auto')")
+    p.add_argument("-m","--formatver", default=None, help="Version digits (e.g. 001)")
 
-    # Validation & extraction behavior
-    p.add_argument("-C", "--checksum", default="crc32", help="Checksum algorithm (header/content/json).")
-    p.add_argument("-s", "--skipchecksum", action="store_true", help="Skip checksum verification while reading.")
-    p.add_argument("-p", "--preserve", action="store_false", help="Do not preserve permissions/times (kept for compatibility).")
-
-    # Misc
-    p.add_argument("-d", "--verbose", action="store_true", help="Verbose logging.")
-    p.add_argument("-T", "--text", action="store_true", help="Treat the first input argument as a text file containing paths (one per line).")
+    p.add_argument("-P","--compression", default="auto", help="Compression: none|zlib|gzip|bz2|xz|auto")
+    p.add_argument("-L","--level", default=None, help="Compression level/preset")
+    p.add_argument("-C","--checksum", default="crc32", help="Checksum algorithm")
+    p.add_argument("-s","--skipchecksum", action="store_true", help="Skip checks while reading")
+    p.add_argument("-d","--verbose", action="store_true", help="Verbose listing")
 
     args = p.parse_args(argv)
 
-    # Choose primary action
-    actions = ['create', 'extract', 'repack', 'list', 'validate']
-    active = next((name for name in actions if getattr(args, name)), None)
-    if not active:
-        p.error("one of --create/--extract/--repack/--list/--validate is required")
-
-    # formatspecs (None => INI auto-fallback inside the alt core)
     formatspecs = _build_formatspecs_from_args(args)
-
-    # Inputs
     inputs = args.input
     infile0 = inputs[0]
-
-    # Compression/level
     compression = args.compression
     level = None if args.level in (None, "",) else int(args.level)
-
-    # Checksum triple
     checksum = args.checksum
-    checks = (checksum, checksum, checksum)
 
-    if active == 'create':
-        if args.text:
-            inputs = _read_listfile(infile0)
+    if args.create:
         if args.convert:
-            if not args.output:
-                p.error("--output is required when using --convert")
+            if not args.output: p.error("--output is required")
             ok = _convert_or_fail(infile0, args.output, formatspecs, checksum, compression, level)
             return 0 if ok else 1
-        if not args.output:
-            p.error("--output is required for --create")
-        A.pack_alt(inputs if not args.text else inputs, args.output, formatspecs=formatspecs,
-                   checksumtypes=checks, compression=compression, compression_level=level)
-        if args.verbose:
-            sys.stderr.write("created: %s\n" % args.output)
+        if not args.output: p.error("--output is required")
+        N.pack_neo(inputs, args.output, formatspecs=formatspecs,
+                   checksumtypes=(checksum, checksum, checksum),
+                   compression=compression, compression_level=level)
+        if args.verbose: sys.stderr.write("created: %s\n" % args.output)
         return 0
 
-    if active == 'repack':
+    if args.repack:
         if args.convert:
-            if not args.output:
-                p.error("--output is required when using --repack --convert")
+            if not args.output: p.error("--output is required")
             ok = _convert_or_fail(infile0, args.output, formatspecs, checksum, compression, level)
             return 0 if ok else 1
-        if not args.output:
-            p.error("--output is required for --repack")
-        A.repack_alt(infile0, args.output, formatspecs=formatspecs,
-                     checksumtypes=checks, compression=compression, compression_level=level)
-        if args.verbose:
-            sys.stderr.write("repacked: %s -> %s\n" % (infile0, args.output))
+        if not args.output: p.error("--output is required")
+        N.repack_neo(infile0, args.output, formatspecs=formatspecs,
+                     checksumtypes=(checksum, checksum, checksum),
+                     compression=compression, compression_level=level)
+        if args.verbose: sys.stderr.write("repacked: %s\n" % args.output)
         return 0
 
-    if active == 'extract':
+    if args.extract:
         outdir = args.output or "."
         if args.convert:
-            tmp_arc = os.path.join(tempfile.gettempdir(), "af_alt_convert.arc")
+            tmp_arc = os.path.join(tempfile.gettempdir(), "pyneofile_convert.neo")
             ok = _convert_or_fail(infile0, tmp_arc, formatspecs, checksum, compression, level)
-            if not ok:
-                return 1
-            infile0_use = tmp_arc
+            if not ok: return 1
+            use = tmp_arc
         else:
-            infile0_use = infile0
-        A.unpack_alt(infile0_use, outdir, formatspecs=formatspecs, skipchecksum=args.skipchecksum, uncompress=True)
-        if args.verbose:
-            sys.stderr.write("extracted to: %s\n" % outdir)
+            use = infile0
+        N.unpack_neo(use, outdir, formatspecs=formatspecs, skipchecksum=args.skipchecksum, uncompress=True)
+        if args.verbose: sys.stderr.write("extracted → %s\n" % outdir)
         return 0
 
-    if active == 'list':
+    if args.list:
         if args.convert:
-            tmp_arc = os.path.join(tempfile.gettempdir(), "af_alt_convert.arc")
+            tmp_arc = os.path.join(tempfile.gettempdir(), "pyneofile_convert.neo")
             ok = _convert_or_fail(infile0, tmp_arc, formatspecs, checksum, compression, level)
-            if not ok:
-                return 1
+            if not ok: return 1
             use = tmp_arc
         else:
             use = infile0
-        names = A.archivefilelistfiles_alt(use, formatspecs=formatspecs, advanced=args.verbose, include_dirs=True)
+        names = N.archivefilelistfiles_neo(use, formatspecs=formatspecs, advanced=args.verbose, include_dirs=True)
         if not args.verbose:
-            for n in names:
-                sys.stdout.write(n + "\n")
+            for n in names: sys.stdout.write(n + "\n")
         else:
             for ent in names:
                 sys.stdout.write("%s\t%s\t%s\t%s\n" % (
                     ent['type'], ent['compression'], ent['size'], ent['name']
                 ))
         return 0
 
-    if active == 'validate':
+    if args.validate:
         if args.convert:
-            tmp_arc = os.path.join(tempfile.gettempdir(), "af_alt_convert.arc")
+            tmp_arc = os.path.join(tempfile.gettempdir(), "pyneofile_convert.neo")
             ok = _convert_or_fail(infile0, tmp_arc, formatspecs, checksum, compression, level)
-            if not ok:
-                return 1
+            if not ok: return 1
             use = tmp_arc
         else:
             use = infile0
-        ok, details = A.archivefilevalidate_alt(use, formatspecs=formatspecs, verbose=args.verbose, return_details=True)
+        ok, details = N.archivefilevalidate_neo(use, formatspecs=formatspecs, verbose=args.verbose, return_details=True)
         if not args.verbose:
             sys.stdout.write("valid: %s\n" % ("yes" if ok else "no"))
         else:
@@ -245,7 +154,7 @@ def main(argv=None):
                 ))
         return 0
 
-    return 0
+    p.error("one of --create/--extract/--repack/--list/--validate is required")
 
 if __name__ == "__main__":
     sys.exit(main())

pyneofile.py

@@ -189,10 +189,10 @@ def _load_formatspecs_from_ini(paths=None, prefer_section=None):
             cands.append(paths)
         else:
             cands.extend(paths)
-    envp = os.environ.get('PYARCHIVE_INI')
+    envp = os.environ.get('PYNEOFILE_INI')
     if envp:
         cands.append(envp)
-    cands.extend(['archivefile.ini', 'catfile.ini', 'foxfile.ini'])
+    cands.extend(['neofile.ini'])
 
     picked = None
     for p in cands: