renumSeq 1.3.2__py3-none-any.whl → 1.4.1__py3-none-any.whl

{renumSeq-1.3.2.dist-info → renumSeq-1.4.1.dist-info}/METADATA

@@ -1,22 +1,21 @@
 Metadata-Version: 2.1
 Name: renumSeq
-Version: 1.3.2
+Version: 1.4.1
 Summary: Tool to renumber image sequences.
 Home-page: https://github.com/jrowellfx/renumSeq
 Author: James Philip Rowell
 Author-email: james@alpha-eleven.com
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS
 Classifier: Development Status :: 5 - Production/Stable
-Requires-Python: >=3.6, <4
+Requires-Python: >=3.7, <4
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: seqLister
+Requires-Dist: seqLister >=1.2.0
+Requires-Dist: lsseq >=2.5.0
 
 # About renumseq
 
@@ -24,23 +23,24 @@ Requires-Dist: seqLister
 which are most
 typically used in CG post-production.
 
-`renumseq` allows you to renumber sequences with an offset, or give them a new 'start' frame.
+`renumseq` allows you to renumber sequences with an offset or give them a new `start` frame.
 It also allows you adjust the padding of the frame numbers.
 
-`renumseq` borrows the syntax of the native output of
+`renumseq` uses the syntax of the native output of
 [`lsseq`](https://github.com/jrowellfx/lsseq) to specify
 the sequence to be renumbered. Therefore it is recommended to
-also install `lsseq` as it makes using `renumseq` easier.
+use `lsseq` as it makes using `renumseq` easier.
 
 For example, use `lsseq` to list a sequence, then
 cut and paste its
-output as the arguments to `renumseq` with appropriate optional
-arguments for setting the offset etc.
+output as the arguments to `renumseq` with the appropriate 
+arguments for setting the offset or new start-frame.
 
 `renumseq` was written to be safe in that it won't
 unintentionally overwrite any existing files
-during the renumbering.  If
-`renumseq` finds that by renumbering a sequence it will write over another frame
+during renumbering.
+
+If `renumseq` finds that by renumbering a sequence it will write over another frame
 outside the range specified then it will skip renumbering that sequence
 (printing a warning) and go onto the next sequence in the list.  Naturally
 there is an option to force `renumseq` to overwrite those files if desired.
@@ -48,20 +48,12 @@ there is an option to force `renumseq` to overwrite those files if desired.
 `renumseq` doesn't need to make temporary copies of files during the renumbering
 (it does a move of the file), so it's fast.
 
-`renumseq` also has a useful option, called `--replaceUnderscore` to change files of this form:
-
-```
-    filename_[n-m].extension
-```
-
-...to this,
-
+`renumseq` also has a useful option, called `--replaceUnderscore`
+that changes any underscore-separators (separating the filename from the
+frame-number) with dot-separators, like this:  
 
-```
-    filename.[n-m].extension
-```
+`filename_[n-m].extension` -> `filename.[n-m].extension`
 
-which, as you can see, replaces the underscore-separator with a dot-separator.  
 `Protip`: If all you want to do is switch the separator from an underscore to a dot, then
 use a zero offset, plus the `--replaceUnderscore` argument.
 
@@ -114,17 +106,13 @@ aaa.002.tif -> aaa.012.tif
 aaa.001.tif -> aaa.011.tif
 ```
 
-Alternatively you can just enclose the argument in quotes like we did above: `'aaa.[001-005].tif'`.
+Alternatively you can just enclose the argument in quotes
+(`'aaa.[001-005].tif'`)
+like we did in the example above.
 
 Type this:
 
 ```
 $ renumseq --help
 ```
-
 ...for much more useful info.
-
-Please contact j a m e s \<at\> a l p h a - e l e v e n . c o m with any bug
-reports, suggestions or praise as the case may be.
-
-

renumSeq-1.4.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+renumseq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+renumseq/__main__.py,sha256=gKc1Vepf2nhLTfJAZcdC_nswjXkG0vt-qnihfPYEqgw,25868
+renumSeq-1.4.1.dist-info/LICENSE,sha256=R6fdEb8ZKpCYTdOM-ZNPs2bVjqLdDfUwiDcx1xP0dCk,1620
+renumSeq-1.4.1.dist-info/METADATA,sha256=TJrzwZdbW6_om5pg-csNfOkw_AOaaNEC8ZAK3ePjI4c,3511
+renumSeq-1.4.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+renumSeq-1.4.1.dist-info/entry_points.txt,sha256=Vu6IBWCxwfVRG3XOZi4ENlMnpe4igvepbHfKy8NGuOY,52
+renumSeq-1.4.1.dist-info/top_level.txt,sha256=N4wzD8IZmW7curkqRcVgXNstK4X3cqZ4K1tVNYsukDI,9
+renumSeq-1.4.1.dist-info/RECORD,,

{renumSeq-1.3.2.dist-info → renumSeq-1.4.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{renumSeq-1.3.2.dist-info → renumSeq-1.4.1.dist-info}/entry_points.txt

@@ -1,3 +1,2 @@
 [console_scripts]
 renumseq = renumseq.__main__:main
-

renumseq/__main__.py

@@ -44,24 +44,30 @@ import argparse
 import os, sys
 import textwrap
 import time
-from datetime import datetime, timedelta, timezone
+from datetime import datetime
 import seqLister
 from enum import Enum
+import subprocess
+import glob
 
 # MAJOR version for incompatible API changes
 # MINOR version for added functionality in a backwards compatible manner
 # PATCH version for backwards compatible bug fixes
 #
-VERSION = "1.3.2"
+VERSION = "1.4.1"
 
 PROG_NAME = "renumseq"
 
+EXIT_NO_ERROR         = 0 # Clean exit.
+EXIT_ERROR            = 1 # Internal error other than argparse - currently not used.
+EXIT_ARGPARSE_ERROR   = 2 # The default code that argparse exits with if bad option.
+
 # List of date formats accepted to set file times with --touch.
 # They are same as the formats used by 'lsseq --onlyShow'.
 #
 # Note: We MUST list %y before %Y in each case below to make sure 
 # that, for example, "200731" get's interpreted as July 31, 2020
-# and not May 1, 2007, as it will if %Y is listed first because
+# and not Mar 1, 2007, as it will if %Y is listed first because
 # strptime() does not enforce zero padding for month, day, etc.
 #
 # Note the ordered pairs below. The second entry is the length
@@ -96,6 +102,7 @@ def main():
     howToTouch = ""   # Set below.
     specificTime = 0  # Set below.
     currentTime = time.time()
+    seqPath = '' # Used for --rename option, set early, also used later.
 
     # Redefine the exception handling routine so that it does NOT
     # do a trace dump if the user types ^C while renumseq is running.
@@ -109,20 +116,15 @@ def main():
     sys.excepthook = new_hook
 
     p = argparse.ArgumentParser(
+        prog=PROG_NAME,
         formatter_class=argparse.RawDescriptionHelpFormatter,
         description=textwrap.dedent('''
             Renumber the frame range of each SEQ listed on the command line.
             SEQ should be specified using lsseq's native format.
             
-            Protip: Turning off globbing, or enclosing SEQ in quotes, or placing
-            backslashes ahead of '[' and ']' will likely be necessary to turn off the special
+            Protip: Enclosing SEQ in quotes will turn off the special
             treatment of '[' and ']' by the shell.
 
-            Caution: The files in the sequence MUST BE correctly padded.
-            Pay attention to lsseq's --showBadPadding for reports of badly padded frame
-            numbers and fix them before renumbering a sequence with this utility.
-            (This is a Rare issue.)
-
             Example usage:
                 $ lsseq
                 aaa.[001-005].tif
@@ -145,10 +147,6 @@ def main():
         help="offset SEQ by this number of frames (can be negative). \
         Frame i becomes i + FRAME_OFFSET")
 
-    p.add_argument("--dryRun", action="store_true",
-        dest="dryRun", default=False,
-        help="Don't renumber SEQ, just display how the \
-        files would have been renumbered. Forces --verbose" )
     p.add_argument("--skip", action="store_false",
         dest="clobber", default=False,
         help="if renumbering a file in SEQ would result in overwriting \
@@ -170,8 +168,14 @@ def main():
         help="set the padding of the frame numbers to be PAD digits. \
         The default action is to leave the padding unchanged. Note, \
         lsseq's native format output properly lists the sequence \
-        range with appropriate padding and can also report when there are \
-        incorrectly padded frame-numbers with --showBadPadding")
+        range with appropriate padding.")
+    p.add_argument("--rename", type=str, nargs=1,
+        dest="newSeqName",
+        default=[],
+        metavar="NEW_SEQNAME",
+        help="Rename the DESCRIPTIVE_NAME part of SEQ from its existing name to NEW_SEQNAME. \
+        When using this option then the command will exit with an error unless \
+        exactly one SEQ is being renamed and/or renumbered.")
     p.add_argument("--replaceUnderscore", action="store_true",
         dest="fixUnderscore", default=False,
         help="in the case that SEQ uses an underscore ('_') \
@@ -187,16 +191,17 @@ def main():
         metavar="[CC]YYMMDD[-hh[mm[ss]]]",
         help="If no date is provided then update the access time of \
         the files being renumbered to the current time. \
-        Otherwise, use the date provided to update the \
-        file's access time. (Default: renumbering a sequence leaves \
-        the access time unchanged.) \
-        When specifying the date, the optional CC (century) defaults to the current century. \
-        The optional '-hh' (hours), 'mm' (minutes) or 'ss' (seconds) \
-        default to zero if not specified. \
-        Note: if this is the last argument on the command line and the optional \
-        date was not specified then \
-        append '--' before the list of SEQs to delineate the end of the options.")
-
+        Otherwise, use the date provided to update the file's access time. \
+        The optional CC (century) defaults to the current century and \
+        '-hh' (hours), 'mm' (minutes) or 'ss' (seconds) \
+        default to zero if not specified.\
+        Note: the default action is to leave \
+        the access time of the SEQ unchanged. ")
+
+    p.add_argument("--dryRun", "--dryrun", action="store_true",
+        dest="dryRun", default=False,
+        help="Don't renumber SEQ, just display how the \
+        files would have been renumbered. Forces --verbose" )
     p.add_argument("--silent", "--quiet", "-s", action="store_true",
         dest="silent", default=False,
         help="suppress all errors and warnings")
@@ -209,20 +214,128 @@ def main():
 
     args = p.parse_args()
 
-    if args.files == [] :
-        sys.exit(0)
+    # The following regular expression is created to match lsseq native
+    # sequence syntax which means (number below refer to parenthesis
+    # groupings (**a**)):
+    #
+    # 0 - one or more of anything,           followed by
+    # 1 - a dot or underscore,               followed by
+    #     an open square bracket,            followed by
+    # 2 - a frame range,                     followed by
+    #     a close square bracket then a dot, followed by
+    # 3 - one or more letters, optionally one dot,
+    #     then one or more letters, then one or more letters and numbers
+    #     and the end of the line.
+    #
+    lsseqPattern = re.compile(r"(.+)([._])\[(-?[0-9]+-?-?[0-9]+)\]\.([a-zA-Z]+\.?[a-zA-Z]+[a-zA-Z0-9]*$)")
+
+    # --rename has nargs set to "1", so parse_args() above will catch
+    # most invalid cases. Now we need to catch four other invalid cases.
+    #
+    # 1) renumseq --rename aaa.[1-10].jpg
+    # 2) renumseq --rename xxx aaa.[1-10].jpg bbb.[1-10].jpg
+    # 3) renumseq --rename aaa.[1-10].jpg bbb.[1-10].jpg
+    # 4) see below
+    #
+    # Case 1) is when the user likely forgot to put the NEW_SEQNAME 
+    #         on the command-line when renaming 'aaa'.
+    # Case 2) is when the user is trying to rename TWO sequences to
+    #         the same name ('xxx') which is obviously undesirable.
+    # Case 3) Hard to say what the user is doing here exactly, but
+    #         they either forgot to add new NEW_SEQNAME *and* to
+    #         remove one or other of the two SEQ from the command-line.
+    #         *OR* they didn't want to actually use --rename at all.
+    #         How to catch this one is if the NEW_SEQNAME
+    #         looks like an SEQ in lsseq native-format.
+    # Case 4) $ lsseq
+    #         aaa.[1-10].jpg
+    #         bbb.[0101-0110].jpg
+    #         $ renumseq --start 20 --rename bbb aaa.[1-10].jpg
+    #
+    #         In this case, regardless of the start frame, or padding differences,
+    #         seq 'aaa' is attempting to be renamed to an SEQ 'bbb' that already exists.
+    #
+    if len(args.newSeqName) == 1 :
+
+        # One other case not mentioned above. --rename is assuming that the "newSeqName" is
+        # just the "descriptiveName" part of the sequence, i.e no path (and no ".<framenum>.ext",
+        # checked below), so check for a possibly embedded path.
+        #
+        if len(args.newSeqName[0].split('/')) > 1 :
+            if not args.silent :
+                print(PROG_NAME, ": error: --rename will rename the sequence in-place, so please omit the path ",
+                    '/'.join(args.newSeqName[0].split('/')[:-1]),
+                    file=sys.stderr, sep='')
+            sys.exit(EXIT_ARGPARSE_ERROR)
+
+        match = lsseqPattern.search(args.newSeqName[0])
 
-    # The following logic means "do nothing" - so just exit cleanly (**a**)
+        if len(args.files) == 0 and match : # If 'not match', command will just exit cleanly below.
+            if not args.silent :
+                print(PROG_NAME, ": error: NEW_SEQNAME not supplied. Perhaps NEW_SEQNAME was",
+                    file=sys.stderr, sep='')
+                print("                 omitted from '--rename ", args.newSeqName[0], "'", " by mistake?",
+                    file=sys.stderr, sep='')
+            sys.exit(EXIT_ARGPARSE_ERROR)
+
+        elif len(args.files) >= 1 and match : # If len() > 1 then also invalid, but this catches both.
+            if not args.silent :
+                print(PROG_NAME, ": error: --rename NEW_SEQNAME should only supply the descriptive-name",
+                    file=sys.stderr, sep='')
+                print("                 part of the new name. That is, ", args.newSeqName[0],
+                    file=sys.stderr, sep='')
+                print("                 appears to be a full lsseq native-format description of a sequence.",
+                    file=sys.stderr, sep='')
+            sys.exit(EXIT_ARGPARSE_ERROR)
+
+        elif len(args.files) > 1 :
+            if not args.silent :
+                print(PROG_NAME, ": error: can NOT rename more than one SEQ at a time.",
+                    file=sys.stderr, sep='')
+            sys.exit(EXIT_ARGPARSE_ERROR)
+
+        # Now check to see if a sequence with NEW_SEQNAME exists already.
+        # This code relies on lsseq >= v2.5.0 be installed.
+        #
+        elif len(args.files) == 1 :
+            seqPath = '/'.join(args.files[0].split('/')[:-1])
+            if len(seqPath) > 0 :
+                seqPath = seqPath + '/'
+
+            # This next globPattern will put us in the ballpark - lsseq will check more carefully
+            # based on this. If NEW_SEQNAME contains a '*', '?', '[' or ']', then this isn't going
+            # to work so well, so hopefully the user isn't trying to rename to something with
+            # a globbing-wildcard as part of the new name.
+            #
+            globPattern = seqPath + args.newSeqName[0] + '[._]' + '[0-9]*.*'
+
+            globResult = glob.glob(globPattern)
+
+            if len(globResult) > 0 :
+                lsseqCmd = ['lsseq', '--looseNumSeparator', '--onlySequences', '--noErrorLists'] + globResult
+                lsseqResult = subprocess.run(lsseqCmd, capture_output=True, text=True)
+                if len(lsseqResult.stdout) > 0 :
+                    if not args.silent :
+                        print(PROG_NAME, ": error: can NOT rename to an existing sequence ",
+                            lsseqResult.stdout,
+                            file=sys.stderr, sep='', end='')
+                    sys.exit(EXIT_ARGPARSE_ERROR)
+
+    if len(args.files) == 0 :
+        sys.exit(EXIT_NO_ERROR)
+
+    # The following logic means "do nothing" - so just exit cleanly (**b**)
     #
     if args.offsetFrames == 0 \
             and args.pad < 0 \
             and not args.fixUnderscore \
-            and args.startFrame == NEVER_START_FRAME :
+            and args.startFrame == NEVER_START_FRAME \
+            and len(args.newSeqName) == 0 :
         if not args.silent :
             print(PROG_NAME,
-                ": warning: no offset, no padding change etc., nothing to do",
+                ": warning: no offset, no rename, no padding change, etc., nothing to do",
                 file=sys.stderr, sep='')
-        sys.exit(0)
+        sys.exit(EXIT_NO_ERROR)
 
     # args.touch is either a string, presumably containing a date (so need to
     # check its validity), the string "0" (meaning --touch was called with NO argument),
@@ -238,7 +351,6 @@ def main():
         howToTouch = Touch.SPECIFIC_TIME
 
         # Loop through list of acceptable formats declared globally.
-        # Note that the order of the formats listed 
         #
         matchedDate = False
         for dateFormat in DATE_FORMAT_LIST :
@@ -273,33 +385,19 @@ def main():
                 print(PROG_NAME,
                     ": error: argument --touch: the time must be of the form [CC]YYMMDD[-hh[mm[ss]]]",
                     file=sys.stderr, sep='')
-            sys.exit(1)
+            sys.exit(EXIT_ARGPARSE_ERROR)
 
         specificTime = int(time.mktime(timeData.timetuple())) # Epoch time
 
     if args.dryRun : # verbose to show how renumbering would occur.
         args.verbose = True
 
-    # The following regular expression is created to match lsseq native sequence syntax
-    # which means (number labels refer to parenthesis groupings **):
-    #
-    # 0 - one or more of anything,           followed by
-    # 1 - a dot or underscore,               followed by
-    #     an open square bracket,            followed by
-    # 2 - a frame range,                     followed by
-    #     a close square bracket then a dot, followed by
-    # 3 - one or more letters, optionally one dot,
-    #     then one or more letters, then one or more letters and numbers
-    #     and the end of the line.
-    #
-    pattern = re.compile(r"(.+)([._])\[(-?[0-9]+-?-?[0-9]+)\]\.([a-zA-Z]+\.?[a-zA-Z]+[a-zA-Z0-9]*$)")
-
     for arg in args.files :
         abortSeq = False
 
         # Check if 'arg' is a sequence in valid lsseq native format
         #
-        match = pattern.search(arg)
+        match = lsseqPattern.search(arg)
         if not match :
             if not args.silent :
                 print(PROG_NAME, ": warning: ", arg,
@@ -310,7 +408,7 @@ def main():
         v = match.groups()
 
         usesUnderscore = (v[1] == '_')
-        seq = [v[0], v[2], v[3]] # base filename, range, file-extension. (see above **)
+        seq = [v[0], v[2], v[3]] # base filename, range, file-extension. (see above (**a**))
 
         # seq might be range with neg numbers. Assume N,M >= 0,
         # then there are only 5 seq cases that we need to be
@@ -384,7 +482,7 @@ def main():
 
             args.offsetFrames = args.startFrame - start
 
-            # This duplicates the test above (**a**) because now
+            # This duplicates the test above (**b**) because now
             # we might have a zero offset for this sequence.
             # Instead of exiting we just skip to the next seq.
             #
@@ -470,8 +568,14 @@ def main():
             origFile = seq[0] + currentSeparator + currentFormatStr.format(i) + '.' + seq[2]
             if os.path.exists(origFile) :
                 origName.append(origFile)
-                newName.append(seq[0] + newSeparator + newFormatStr.format(i+args.offsetFrames) \
-                    + '.' + seq[2])
+                if len(args.newSeqName) == 1 :
+                    newName.append(seqPath + args.newSeqName[0] + newSeparator + \
+                        newFormatStr.format(i+args.offsetFrames) \
+                        + '.' + seq[2])
+                else :
+                    newName.append(seq[0] + newSeparator + \
+                        newFormatStr.format(i+args.offsetFrames) \
+                        + '.' + seq[2])
 
         if origName == [] :
             if not args.silent :

renumSeq-1.3.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-renumseq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-renumseq/__main__.py,sha256=6L07_jK7G5ZqSPhd9t7nHuha7VVgN8ZtsoFmuQeD8uw,20774
-renumSeq-1.3.2.dist-info/LICENSE,sha256=R6fdEb8ZKpCYTdOM-ZNPs2bVjqLdDfUwiDcx1xP0dCk,1620
-renumSeq-1.3.2.dist-info/METADATA,sha256=hOHdxCB1ZNma_eZybhbLn4vGsVG70HXQnmq3CKGUaUw,3653
-renumSeq-1.3.2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-renumSeq-1.3.2.dist-info/entry_points.txt,sha256=rGNSv4SOqnQWjgiPUaXHLBE_xiQRX0lgB-Ig-lmB5_Y,53
-renumSeq-1.3.2.dist-info/top_level.txt,sha256=N4wzD8IZmW7curkqRcVgXNstK4X3cqZ4K1tVNYsukDI,9
-renumSeq-1.3.2.dist-info/RECORD,,