Merge pull request #509 from cchampet/dev_upToV0.12.7

New patch v0.12.7

Author: cchampet

applications/sam/common/samUtils.py

@@ -69,23 +69,17 @@ def setLogLevel(self, tuttleVerboseLevel):
         """
         for handler in self.logger.handlers:
             if tuttleVerboseLevel is 0:
-                # CRITICAL
-                handler.setLevel(50)
+                handler.setLevel(logging.CRITICAL)
             elif tuttleVerboseLevel is 1:
-                # ERROR
-                handler.setLevel(40)
+                handler.setLevel(logging.ERROR)
             elif tuttleVerboseLevel is 2:
-                # WARNING
-                handler.setLevel(30)
+                handler.setLevel(logging.WARNING)
             elif tuttleVerboseLevel is 3:
-                # INFO
-                handler.setLevel(20)
+                handler.setLevel(logging.INFO)
             elif tuttleVerboseLevel >= 4:
-                # DEBUG (and trace)
-                handler.setLevel(10)
+                handler.setLevel(logging.DEBUG)
             else:
-                # WARNING
-                handler.setLevel(30)
+                handler.setLevel(logging.WARNING)
 
 
 class SamFormatter(logging.Formatter):
@@ -213,19 +207,17 @@ def getSequenceNameWithFormatting(sequence, formatChosen):
     """
     Return the sequence name with a specific formatting (from nuke, rv...).
     """
-    sequenceName = sequence.getPrefix()
     if formatChosen == 'rv':
+        sequenceName = sequence.getPrefix()
         sequenceName += (str(sequence.getFirstTime()) + '-' + str(sequence.getLastTime()))
-        sequenceName += '@' * sequence.getPadding()
-        if not sequence.getPadding():
+        sequenceName += '@' * sequence.getFixedPadding()
+        if not sequence.getFixedPadding():
             sequenceName += '@'  # no padding
+        sequenceName += sequence.getSuffix()
     elif formatChosen == 'nuke':
-        sequenceName += '%0' + str(sequence.getPadding()) + 'd'
+        sequenceName = sequence.getFilenameWithPrintfPattern()
     else:  # default formatting
-        sequenceName += '#' * sequence.getPadding()
-        if not sequence.getPadding():
-            sequenceName += '@'  # no padding
-    sequenceName += sequence.getSuffix()
+        sequenceName = sequence.getFilenameWithStandardPattern()
     return sequenceName
 
 

applications/sam/sam_cp.py

@@ -20,7 +20,7 @@ def __init__(self):
         self.command = 'cp'
         self.help = 'to copy sequences'
         self.description = str(colored.green('''
-            Copy sequences in a directory.
+            Copy one or more sequences to a directory.
             '''))
         self._operation = shutil.copy2
 

applications/sam/sam_do.py

@@ -527,6 +527,7 @@ def run(self, parser):
             self.logger.error('No tuttle graph to compute.')
             exit(1)
 
+        error = 0
         # Compute the corresponding tuttle graphs
         for graph, nodes in graphsWithNodes:
             # Options of process
@@ -565,8 +566,10 @@ def run(self, parser):
             except Exception as e:
                 self.logger.error('Tuttle graph computation has failed.')
                 self.logger.debug(e)
+                error = 1
             self.logger.info('Memory usage: ' + str(int(samUtils.memoryUsageResource())) + 'KB')
 
+        exit(error)
 
 if __name__ == '__main__':
     # Create the tool

applications/sam/sam_ls.py

@@ -230,7 +230,7 @@ def printItems(self, items, args, detectionMethod, filters, level=0):
 
                 try:
                     newFolder = os.path.join(item.getFolder(), item.getFilename())
-                    self.logger.info('Launch a browse on "' + newFolder + '" with the following filters: ' + str(filters))
+                    self.logger.debug('Browse in "' + newFolder + '" with the following filters: ' + str(filters))
                     newItems = sequenceParser.browse(newFolder, detectionMethod, filters)
                     level += 1
                     self.printItems(newItems, args, detectionMethod, filters, level)
@@ -249,15 +249,22 @@ def run(self, parser):
         # Set sam log level
         self.setLogLevel(args.verbose)
 
-        # inputs to scan
         inputs = []
-        for input in args.inputs:
-            # if exists add the path
-            if os.path.exists(input):
-                inputs.append(input)
-            # else use it as a filter expression
-            else:
-                args.expression.append(input)
+        # for each input to scan
+        for inputPath in args.inputs:
+            # if the input is a directory, add it and continue
+            if os.path.isdir(inputPath):
+                inputs.append(inputPath)
+                continue
+            # else split the input to a path and a filename
+            subPath = os.path.dirname(inputPath)
+            if not subPath:
+                subPath = '.'
+            filename = os.path.basename(inputPath)
+            # add the path and the filename as an expression
+            inputs.append(subPath)
+            if filename:
+                args.expression.append(filename)
         if not inputs:
             inputs.append(os.getcwd())
 
@@ -280,18 +287,19 @@ def run(self, parser):
             filters.append(expression)
 
         # get list of items for each inputs
-        for input in inputs:
+        for inputPath in inputs:
             items = []
             try:
-                self.logger.info('Launch a browse on "' + input + '" with the following filters: ' + str(filters))
-                items = sequenceParser.browse(input, detectionMethod, filters)
+                self.logger.debug('Browse in "' + inputPath + '" with the following filters: ' + str(filters))
+                items = sequenceParser.browse(inputPath, detectionMethod, filters)
             except IOError as e:
+                self.logger.debug('IOError raised: "' + str(e) + '".')
                 # if the given input does not correspond to anything
                 if 'No such file or directory' in str(e):
                     # try to create a sequence from the given input
                     sequence = sequenceParser.Sequence()
-                    self.logger.info('Launch a browseSequence on "' + input + '".')
-                    isSequence = sequenceParser.browseSequence(sequence, input)
+                    self.logger.debug('BrowseSequence on "' + inputPath + '".')
+                    isSequence = sequenceParser.browseSequence(sequence, inputPath)
                     if isSequence:
                         item = sequenceParser.Item(sequence, os.getcwd())
                         # check if the sequence contains at least one element
@@ -301,22 +309,23 @@ def run(self, parser):
                     else:
                         self.logger.warning(e)
                         continue
-                # else it's not a directory: try a new browse with the given input name as filter
+                # else it's not a directory
                 else:
+                    self.logger.debug('Try a new browse with the given input name as filter.')
                     # new path to browse
-                    newBrowsePath = os.path.dirname(input)
+                    newBrowsePath = os.path.dirname(inputPath)
                     if not newBrowsePath:
                         newBrowsePath = '.'
                     # new filter
                     newFilter = []
                     newFilter.extend(filters)
-                    newFilter.append(os.path.basename(input))
+                    newFilter.append(os.path.basename(inputPath))
                     # new browse
-                    self.logger.info('Launch a browse on "' + newBrowsePath + '" with the following filters: ' + str(newFilter))
+                    self.logger.debug('Browse in "' + newBrowsePath + '" with the following filters: ' + str(newFilter))
                     items += sequenceParser.browse(newBrowsePath, detectionMethod, newFilter)
 
             if not len(items):
-                self.logger.warning('No items found for input "' + input + '".')
+                self.logger.warning('No items found for input "' + inputPath + '".')
             else:
                 self.printItems(items, args, detectionMethod, filters)
 

applications/sam/sam_mv.py

@@ -25,14 +25,14 @@ def __init__(self):
         self.command = 'mv'
         self.help = 'to move sequences'
         self.description = str(colored.green('''
-            Move sequences in a directory.
-            Rename sequences if the output directory is the same as the input.
+            Move one or more sequences to a directory.
+            Rename / retime a sequence.
             '''))
         self._operation = shutil.move
 
     def fillParser(self, parser):
-        parser.add_argument('inputs', metavar='INPUTS', nargs='+', action='store', help='list of inputs').completer = samUtils.sequenceParserCompleter
-        parser.add_argument('output', metavar='OUTPUT', help='the output to write').completer = samUtils.sequenceParserCompleter
+        parser.add_argument('inputs', metavar='INPUTS', nargs='+', action='store', help='list of inputs (only sequences)').completer = samUtils.sequenceParserCompleter
+        parser.add_argument('output', metavar='OUTPUT', help='the output to write (sequence or directory)').completer = samUtils.sequenceParserCompleter
 
         # Options
         parser.add_argument('-o', '--offset', dest='offset', type=int, help='retime the sequence with the given offset')
@@ -48,6 +48,7 @@ def fillParser(self, parser):
 
         parser.add_argument('--detect-negative', dest='detectNegative', action='store_true', help='detect negative numbers instead of detecting "-" as a non-digit character')
         parser.add_argument('-v', '--verbose', dest='verbose', action=samUtils.SamSetVerboseAction, default=2, help='verbose level (0/fatal, 1/error, 2/warn(by default), 3/info, 4(or upper)/debug)')
+        parser.add_argument('--dry-run', dest='dryRun', action='store_true', help='only print what it will do (will force verbosity to info)')
 
     def _getSequenceManipulators(self, inputSequence, args):
         """
@@ -86,10 +87,11 @@ def _getSequenceManipulators(self, inputSequence, args):
 
         return {'first': first, 'last': last, 'offset': offset, 'holes': holesToRemove}
 
-    def _processSequence(self, inputItem, outputSequence, outputSequencePath, moveManipulators):
+    def _processSequence(self, inputItem, outputSequence, outputSequencePath, moveManipulators, dryRun):
         """
         Apply operation to the sequence contained in inputItem (used by sam-mv and sam-cp).
         Depending on args, update the frame ranges of the output sequence.
+        Return if the operation was a success or not.
 
         :param inputItem: the item which contains the input sequence to process (move, copy...)
         :param outputSequence: the output sequence to write (destination of move, copy...)
@@ -101,17 +103,20 @@ def _processSequence(self, inputItem, outputSequence, outputSequencePath, moveMa
                 offset used to retime the output sequence,
                 list of holes to remove in the output sequence
             }
+        :param dryRun: only print what it will do.
         """
         # create output directory if not exists
         try:
             if not os.path.exists(outputSequencePath):
-                os.makedirs(outputSequencePath)
+                # sam-rm --dry-run
+                if not dryRun:
+                    os.makedirs(outputSequencePath)
         except Exception as e:
             self.logger.error('Cannot create directory tree for "' + outputSequencePath + '": ' + str(e))
-            exit(-1)
+            return 1
 
-        # print brief of the operation
-        self.logger.info(os.path.join(inputItem.getFolder(), str(inputItem.getSequence())) + ' -> ' + os.path.join(outputSequencePath, str(outputSequence)))
+        # log brief of the operation
+        self.logger.info(os.path.join(self.command + ' ' + inputItem.getFolder(), str(inputItem.getSequence())) + ' to ' + os.path.join(outputSequencePath, str(outputSequence)))
 
         # get frame ranges
         inputFrameList = list(inputItem.getSequence().getFramesIterable(moveManipulators['first'], moveManipulators['last']))
@@ -128,14 +133,18 @@ def _processSequence(self, inputItem, outputSequence, outputSequencePath, moveMa
             # security: check if file already exist
             if os.path.exists(outputPath):
                 self.logger.error('The output path "' + outputPath + '" already exist!')
-                exit(-1)
+                return 1
 
             # process the image at time
-            self._operation(inputPath, outputPath)
+            self.logger.info(inputPath + ' -> ' + outputPath)
+            # sam-rm --dry-run
+            if not dryRun:
+                self._operation(inputPath, outputPath)
 
     def _getSequenceItemFromPath(self, inputPath, detectNegative):
         """
-        Get an Item (which corresponds to a sequence) from a path.
+        Return an Item (which corresponds to a sequence) from a path.
+        Return None if the operation failed.
         """
         # get input path and name
         inputSequencePath = os.path.dirname(inputPath)
@@ -152,16 +161,16 @@ def _getSequenceItemFromPath(self, inputPath, detectNegative):
         inputItems = sequenceParser.browse(inputSequencePath, detectionMethod, [inputSequenceName])
         if not len(inputItems):
             self.logger.error('No existing file corresponds to the given input sequence: ' + inputPath)
-            exit(-1)
+            return None
         if len(inputItems) > 1:
             self.logger.error('Several items ' + str([item.getFilename() for item in inputItems]) + ' correspond to the given input sequence: ' + inputPath)
-            exit(-1)
+            return None
 
         # check if the item is a sequence
         inputItem = inputItems[0]
         if inputItem.getType() != sequenceParser.eTypeSequence:
             self.logger.error('Input is not a sequence: ' + inputItem.getFilename())
-            exit(-1)
+            return None
 
         return inputItem
 
@@ -173,26 +182,39 @@ def run(self, parser):
         args = parser.parse_args()
 
         # Set sam log level
-        self.setLogLevel(args.verbose)
+        # sam-rm --dry-run
+        if args.dryRun:
+            self.setLogLevel(3) # info
+        else:
+            self.setLogLevel(args.verbose)
 
         # check command line
         if args.offset and (args.outputFirst is not None or args.outputLast is not None):
             self.logger.error('You cannot cumulate multiple options to modify the time.')
             exit(-1)
 
-        # Get output path
-        outputSequencePath = os.path.dirname(args.output)
-        if not outputSequencePath:
-            outputSequencePath = '.'
-
         # Get output sequence
         outputSequence = sequenceParser.Sequence()
         outputSequenceName = os.path.basename(args.output)
         outputIsSequence = outputSequence.initFromPattern(outputSequenceName, sequenceParser.ePatternDefault)
 
+        # Get output path
+        if outputIsSequence:
+            outputSequencePath = os.path.dirname(args.output)
+            # if output path is the same as input
+            if not len(outputSequencePath):
+                outputSequencePath = '.'
+        else:
+            outputSequencePath = args.output
+        self.logger.debug('Output sequence path is "' + outputSequencePath + '".')
+
         # For each input
-        for input in args.inputs:
-            inputItem = self._getSequenceItemFromPath(input, args.detectNegative)
+        error = 0
+        for inputPath in args.inputs:
+            inputItem = self._getSequenceItemFromPath(inputPath, args.detectNegative)
+            if inputItem is None:
+                error = 1
+                continue
 
             if not outputIsSequence:
                 outputSequence = sequenceParser.Sequence(inputItem.getSequence())
@@ -201,8 +223,11 @@ def run(self, parser):
             moveManipulators = self._getSequenceManipulators(inputItem.getSequence(), args)
 
             # move sequence
-            self._processSequence(inputItem, outputSequence, outputSequencePath, moveManipulators)
+            err = self._processSequence(inputItem, outputSequence, outputSequencePath, moveManipulators, args.dryRun)
+            if err:
+                error = err
 
+        exit(error)
 
 if __name__ == '__main__':
     # Create the tool