pyseq 0.9.1__py3-none-any.whl

pyseq/__init__.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2011-2025, Ryan Galloway (ryan@rsgalloway.com)
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  - Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  - Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  - Neither the name of the software nor the names of its contributors
+#    may be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+
+__doc__ = """PySeq is a python module that finds groups of items that follow a naming
+convention containing a numerical sequence index, e.g. ::
+
+    fileA.001.png, fileA.002.png, fileA.003.png...
+
+and serializes them into a compressed sequence string representing the entire
+sequence, e.g. ::
+
+    fileA.1-3.png
+
+It should work regardless of where the numerical sequence index is embedded
+in the name.
+
+Docs and latest version available for download at
+
+   http://github.com/rsgalloway/pyseq
+"""
+
+__author__ = "Ryan Galloway"
+__version__ = "0.9.1"
+
+from .seq import *

pyseq/config.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2011-2025, Ryan Galloway (ryan@rsgalloway.com)
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  - Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  - Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  - Neither the name of the software nor the names of its contributors
+#    may be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+
+__doc__ = """
+Contains pyseq configs and default settings.
+"""
+
+import os
+import re
+
+# default serialization format string
+DEFAULT_FORMAT = "%h%r%t"
+default_format = os.getenv("PYSEQ_DEFAULT_FORMAT", DEFAULT_FORMAT)
+
+# default serialization format string for global sequences
+DEFAULT_GLOBAL_FORMAT = "%4l %h%p%t %R"
+global_format = os.getenv("PYSEQ_GLOBAL_FORMAT", DEFAULT_GLOBAL_FORMAT)
+
+# use strict padding on sequences (pad length must match)
+PYSEQ_STRICT_PAD = os.getenv("PYSEQ_STRICT_PAD", 0)
+PYSEQ_NOT_STRICT = os.getenv("PYSEQ_NOT_STRICT", 1)
+strict_pad = int(PYSEQ_STRICT_PAD) == 1 or int(PYSEQ_NOT_STRICT) == 0
+
+# regex pattern for matching all numbers in a filename
+digits_re = re.compile(r"\d+")
+
+# regex pattern for matching frame numbers only
+# the default is \d+ for maximum compatibility
+DEFAULT_FRAME_PATTERN = r"\d+"
+PYSEQ_FRAME_PATTERN = os.getenv("PYSEQ_FRAME_PATTERN", DEFAULT_FRAME_PATTERN)
+
+
+def set_frame_pattern(pattern: str = DEFAULT_FRAME_PATTERN):
+    """
+    Set the regex pattern for matching frame numbers.
+
+    :param pattern: The regex pattern to use for matching frame numbers.
+    """
+    global frames_re
+    global PYSEQ_FRAME_PATTERN
+    PYSEQ_FRAME_PATTERN = pattern
+    try:
+        frames_re = re.compile(pattern)
+    except Exception as e:
+        print("Error: Invalid regex pattern: %s" % e)
+        frames_re = re.compile(DEFAULT_FRAME_PATTERN)
+
+
+# set the default frame pattern
+set_frame_pattern(PYSEQ_FRAME_PATTERN)
+
+# regex for matching format directives
+format_re = re.compile(r"%(?P<pad>\d+)?(?P<var>\w+)")
+
+# character to join explicit frame ranges on
+DEFAULT_RANGE_SEP = ", "
+range_join = os.getenv("PYSEQ_RANGE_SEP", DEFAULT_RANGE_SEP)

pyseq/lss.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2011-2025, Ryan Galloway (ryan@rsgalloway.com)
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  - Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  - Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  - Neither the name of the software nor the names of its contributors
+#    may be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+
+__doc__ = """
+Contains the main lss functions for the pyseq module.
+"""
+
+import glob
+import optparse
+import os
+import sys
+from typing import Any, Optional
+
+from pyseq import __version__, get_sequences
+from pyseq import seq as pyseq
+from pyseq.util import cli_catch_keyboard_interrupt
+from pyseq import walk
+
+
+def tree(source: str, level: Optional[int], seq_format: str):
+    """Recursively walk from the source and display all the folders and sequences."""
+    if sys.stdout.isatty():
+        blue = "\033[94m"
+        endc = "\033[0m"
+    else:
+        blue = ""
+        endc = ""
+    ends = {}
+    done = []
+
+    print("{0}{1}".format(blue, os.path.relpath(source)))
+
+    for root, dirs, seqs in walk(source, level):
+        if len(dirs) > 0:
+            ends[root] = dirs[-1]
+        else:
+            ends[root] = None
+
+        sp = ""
+        if root != sorted(source):
+            p = root
+            while p != source:
+                dir_name, base = os.path.split(p)
+                if dir_name == source:
+                    break
+                elif dir_name in done:
+                    sp = "    " + sp
+                elif ends[dir_name] != base:
+                    sp = "│   " + sp
+                elif ends[dir_name] == base:
+                    sp = "│   " + sp
+                else:
+                    sp = "    " + sp
+                p = dir_name
+
+        base = os.path.basename(root)
+        if root == source:
+            pass
+        elif ends[os.path.dirname(root)] == base:
+            print("".join([sp, "└── ", "%s%s%s" % (blue, base, endc)]))
+            done.append(root)
+            ends[os.path.dirname(root)] = None
+            sp += "    "
+        else:
+            print("".join([sp, "├── ", "%s%s%s" % (blue, base, endc)]))
+            sp += "│   "
+
+        sequence_length = len(seqs)
+        for i, seq in enumerate(seqs):
+            if i == (sequence_length - 1) and len(dirs) == 0:
+                print("".join([sp, "└── ", seq.format(seq_format)]))
+            else:
+                print("".join([sp, "├── ", seq.format(seq_format)]))
+    print(endc)
+
+
+def _recur_cb(option: Any, opt_str: str, value: Optional[str], parser: Any):
+    """Callback for the `recursive` argument."""
+    if value is None:
+        value = -1
+    else:
+        value = int(value)
+    setattr(parser.values, option.dest, value)
+
+
+@cli_catch_keyboard_interrupt
+def main():
+    """Command-line interface."""
+
+    usage = (
+        """
+lss [path] [-f format] [-d] [-r]
+
+Formatting options:
+
+    You can format the output of lss using the --format option and passing
+    in a format string.
+
+    Default format string is "%s"
+
+    Supported directives:
+        %%s   sequence start
+        %%e   sequence end
+        %%l   sequence length
+        %%f   list of found files
+        %%m   list of missing files
+        %%p   padding, e.g. %%06d
+        %%r   absolute range, start-end
+        %%R   expanded range, start-end [missing]
+        %%d   disk usage
+        %%h   string preceding sequence number
+        %%t   string after the sequence number
+
+    Format directives support padding, for example: "%%04l".
+    """
+        % pyseq.global_format
+    )
+
+    parser = optparse.OptionParser(usage=usage, version="%prog " + __version__)
+    parser.add_option(
+        "-f",
+        "--format",
+        dest="format",
+        default=None,
+        help="Format the sequence string.",
+    )
+    parser.add_option(
+        "-r",
+        "--recursive",
+        dest="recursive",
+        action="callback",
+        callback=_recur_cb,
+        help="Walks the entire directory structure.",
+    )
+    parser.add_option(
+        "-s",
+        "--strict",
+        dest="strict",
+        action="store_true",
+        default=pyseq.strict_pad,
+        help="Strict padding (default false).",
+    )
+    (options, args) = parser.parse_args()
+
+    pyseq.strict_pad = options.strict
+
+    # stdin is piped, read from stdin if no cli args provided
+    if not args and not sys.stdin.isatty():
+        args = [line.strip() for line in sys.stdin if line.strip()]
+
+    # if no args are given, use cwd
+    elif len(args) == 0:
+        args = [os.getcwd()]
+
+    items = []
+    for path in args:
+        if os.path.isdir(path):
+            join = os.path.join
+            items = [join(path, x) for x in os.listdir(path)]
+        else:
+            items.extend(glob.glob(path))
+
+    if options.recursive is None:
+        for seq in get_sequences(items):
+            print(seq.format(options.format or pyseq.global_format))
+    else:
+        level = options.recursive
+        for path in args:
+            path = os.path.abspath(path.rstrip(os.sep))
+            if not os.path.isdir(path):
+                continue
+            tree(path, level, options.format or "%h%r%t")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pyseq/scopy.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2011-2025, Ryan Galloway (ryan@rsgalloway.com)
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  - Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  - Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  - Neither the name of the software nor the names of its contributors
+#    may be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+
+__doc__ = """
+Contains the main scopy functions for the pyseq module.
+"""
+
+import sys
+import os
+import argparse
+import shutil
+import fnmatch
+from typing import Optional
+
+import pyseq
+from pyseq.util import (
+    cli_catch_keyboard_interrupt,
+    is_compressed_format_string,
+    resolve_sequence,
+)
+
+
+def copy_sequence(
+    seq: pyseq.Sequence,
+    src_dir: str,
+    dest_dir: str,
+    rename: Optional[str] = None,
+    renumber: Optional[int] = None,
+    pad: Optional[int] = None,
+    force: bool = False,
+    dryrun: bool = False,
+    verbose: bool = False,
+):
+    """Copy a sequence of files from src_dir to dest_dir.
+
+    :param seq: The sequence object to copy.
+    :param src_dir: The source directory containing the files.
+    :param dest_dir: The destination directory to copy files to.
+    :param rename: Optional new basename for the copied files.
+    :param renumber: Optional new starting frame number.
+    :param pad: Optional number of digits for padding the frame numbers.
+    :param force: If True, overwrite existing files.
+    :param dryrun: If True, print the operations without executing them.
+    :param verbose: If True, print detailed information about the operations.
+    """
+    dest_basename = rename or seq.head()
+    dest_pad = pad or seq.pad
+    start_frame = renumber or seq.start()
+
+    for i, frame in enumerate(seq):
+        src_path = os.path.join(src_dir, frame.name)
+        frame_num = start_frame + i
+        dest_frame_name = f"{dest_basename}{frame_num:0{dest_pad}d}{seq.tail()}"
+        dest_path = os.path.join(dest_dir, dest_frame_name)
+
+        if verbose or dryrun:
+            print(f"{src_path} -> {dest_path}")
+
+        if not dryrun:
+            os.makedirs(dest_dir, exist_ok=True)
+            if os.path.exists(dest_path) and not force:
+                print(
+                    f"File exists: {dest_path} (use --force to overwrite)",
+                    file=sys.stderr,
+                )
+                continue
+            shutil.copy2(src_path, dest_path)
+
+
+@cli_catch_keyboard_interrupt
+def main():
+    """Main function to parse cli args and copy sequences."""
+
+    parser = argparse.ArgumentParser(
+        description="Copy image sequences with renaming/renumbering support",
+    )
+    parser.add_argument(
+        "sources",
+        nargs="+",
+        help="Source sequences (wildcards or compressed format strings)",
+    )
+    parser.add_argument(
+        "dest",
+        help="Destination directory",
+    )
+    parser.add_argument(
+        "--rename",
+        help="Rename sequence basename",
+    )
+    parser.add_argument(
+        "--renumber",
+        type=int,
+        help="New starting frame",
+    )
+    parser.add_argument(
+        "--pad",
+        type=int,
+        help="Padding digits",
+    )
+    parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        help="Overwrite existing files",
+    )
+    parser.add_argument(
+        "-d",
+        "--dryrun",
+        action="store_true",
+        help="Preview copy without performing it",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Verbose output",
+    )
+    args = parser.parse_args()
+
+    if not os.path.isdir(args.dest):
+        print(f"Error: destination {args.dest} is not a directory", file=sys.stderr)
+        return 1
+
+    for source in args.sources:
+        try:
+            if is_compressed_format_string(source):
+                seq = resolve_sequence(source)
+                dirname = os.path.dirname(source) or "."
+            else:
+                # treat as glob
+                dirname = os.path.dirname(source) or "."
+                basename = os.path.basename(source)
+                matches = [
+                    f for f in os.listdir(dirname) if fnmatch.fnmatchcase(f, basename)
+                ]
+                sequences = pyseq.get_sequences(matches)
+                if not sequences:
+                    print(f"No sequence found matching {source}", file=sys.stderr)
+                    continue
+                seq = sequences[0]
+
+            copy_sequence(
+                seq,
+                dirname,
+                args.dest,
+                rename=args.rename,
+                renumber=args.renumber,
+                pad=args.pad,
+                force=args.force,
+                dryrun=args.dryrun,
+                verbose=args.verbose,
+            )
+
+        except Exception as e:
+            print(f"Error processing {source}: {e}", file=sys.stderr)
+            return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pyseq/sdiff.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2011-2025, Ryan Galloway (ryan@rsgalloway.com)
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  - Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  - Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  - Neither the name of the software nor the names of its contributors
+#    may be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+
+__doc__ = """
+Contains the main sdiff functions for the pyseq module.
+"""
+
+import argparse
+import json
+import sys
+
+import pyseq
+from pyseq.util import cli_catch_keyboard_interrupt
+from pyseq.util import resolve_sequence
+
+
+def diff_sequences(
+    seq1: pyseq.Sequence,
+    seq2: pyseq.Sequence,
+    compare_size: bool = False,
+):
+    """Compares two sequences and returns a dictionary of differences.
+
+    :param seq1: The first sequence to compare.
+    :param seq2: The second sequence to compare.
+    :param compare_size: Boolean indicating whether to compare disk usage.
+    :return: A dictionary containing differences between the two sequences.
+    """
+
+    def intval(val):
+        try:
+            return int(val)
+        except:
+            return None
+
+    diff = {
+        "head": (seq1.head(), seq2.head()),
+        "tail": (seq1.tail(), seq2.tail()),
+        "pad": (seq1.pad, seq2.pad),
+        "start": (seq1.start(), seq2.start()),
+        "end": (seq1.end(), seq2.end()),
+        "length": (seq1.length(), seq2.length()),
+        "missing": {
+            "a_only": sorted(set(seq1.missing()) - set(seq2.missing())),
+            "b_only": sorted(set(seq2.missing()) - set(seq1.missing())),
+        },
+    }
+
+    if compare_size:
+        disk_a = intval(seq1.format("%d"))
+        disk_b = intval(seq2.format("%d"))
+        diff["disk_bytes"] = [disk_a, disk_b]
+        diff["disk_human"] = [seq1.format("%H"), seq2.format("%H")]
+
+    return diff
+
+
+def print_diff(diff: dict, compare_size: bool = False):
+    """Prints the differences between two sequences.
+
+    :param diff: The dictionary containing differences between sequences.
+    :param compare_size: Boolean indicating whether to compare disk usage.
+    """
+
+    def show(label: str, a: str, b: str):
+        if a != b:
+            print(f"{label} mismatch:\n  A: {a}\n  B: {b}")
+
+    show("Head", *diff["head"])
+    show("Tail", *diff["tail"])
+    show("Padding", *diff["pad"])
+    show("Start", *diff["start"])
+    show("End", *diff["end"])
+    show("Length", *diff["length"])
+
+    a_only = diff["missing"]["a_only"]
+    b_only = diff["missing"]["b_only"]
+    if a_only:
+        print(f"Missing in A: {a_only}")
+    if b_only:
+        print(f"Missing in B: {b_only}")
+
+    if compare_size and "disk_bytes" in diff:
+        a, b = diff["disk_human"]
+        if a != b:
+            print(f"Disk usage mismatch:\n  A: {a}\n  B: {b}")
+
+
+@cli_catch_keyboard_interrupt
+def main():
+    """Main function to parse arguments and display sequence diffs."""
+
+    parser = argparse.ArgumentParser(
+        description="Compare two file sequences and report differences.",
+    )
+    parser.add_argument(
+        "seq1",
+        help="First sequence (glob or %%d format)",
+    )
+    parser.add_argument(
+        "seq2",
+        help="Second sequence",
+    )
+    parser.add_argument(
+        "--size",
+        action="store_true",
+        help="Compare disk usage",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output result as JSON",
+    )
+    args = parser.parse_args()
+
+    try:
+        s1 = resolve_sequence(args.seq1)
+        s2 = resolve_sequence(args.seq2)
+    except Exception as e:
+        print(f"sdiff: error resolving sequence: {e}", file=sys.stderr)
+        return 1
+
+    diff = diff_sequences(s1, s2, compare_size=args.size)
+
+    if args.json:
+        print(json.dumps(diff, indent=4))
+    else:
+        print(f"Sequence A: {str(s1)}")
+        print(f"Sequence B: {str(s2)}\n")
+        print_diff(diff, compare_size=args.size)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())