diff --git a/tren.py b/tren.py index f1b1756..795d4b4 100755 --- a/tren.py +++ b/tren.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python +#!/usr/bin/env python2 # tren.py # Copyright (c) 2010-2020 TundraWare Inc. # For Updates See: http://www.tundraware.com/Software/tren @@ -9,7 +9,7 @@ BASENAME = PROGNAME.split(".py")[0] PROGENV = BASENAME.upper() INCLENV = PROGENV + "INCL" -RCSID = "$Id: tren.py,v 1.242 2011/08/01 18:07:17 tundra Exp $" +RCSID = "$Id: tren.py,v 1.243 2020/11/07 18:07:17 tundra Exp $" VERSION = RCSID.split()[2] # Copyright Information @@ -439,7 +439,7 @@ 'u' : str.upper } -CASEOPS = list(CASETBL.keys()) +CASEOPS = CASETBL.keys() CASEOPS.sort() @@ -690,8 +690,7 @@ try: pathname, basename = os.path.split(fullname) stats = os.stat(fullname) - except (IOError, OSError) as xxx_todo_changeme2: - (errno, errstr) = xxx_todo_changeme2.args + except (IOError, OSError), (errno, errstr): ErrorMsg(eFILEOPEN % (fullname, errstr)) # Some operating systems (Windows) terminate the path with @@ -747,7 +746,7 @@ statflag, storage, order = seqtype - vieworder = list(storage.keys()) + vieworder = storage.keys() vieworder.sort() # Sort alphabetically when multiple filenames @@ -1277,8 +1276,7 @@ try: os.rename(fullold, fullnew) - except OSError as xxx_todo_changeme: - (errno, errstr) = xxx_todo_changeme.args + except OSError, (errno, errstr): ErrorMsg(eRENAMEFAIL % (fullold, fullnew, errstr)) self.indentlevel -= 1 @@ -1503,7 +1501,7 @@ token = r[2][1:] found = False - for seqtoken in list(self.SortViews.keys()) + [ORDERBYADATE, ORDERBYCDATE, ORDERBYMDATE]: + for seqtoken in self.SortViews.keys() + [ORDERBYADATE, ORDERBYCDATE, ORDERBYMDATE]: if token.split(ALPHADELIM)[0] == (seqtoken): @@ -1831,7 +1829,7 @@ DebugMsg(dCURSTATE) DebugMsg(SEPARATOR) - opts = list(ProgramOptions.keys()) + opts = ProgramOptions.keys() opts.sort() for o in opts: DebugMsg(ColumnPad([o, ProgramOptions[o]])) @@ -2069,8 +2067,7 @@ OPTIONS = OPTIONS[:i] + n + OPTIONS[i+1:] - except IOError as xxx_todo_changeme1: - (errno, errstr) = xxx_todo_changeme1.args + except IOError, (errno, errstr): ErrorMsg(eFILEOPEN % (inclfile, errstr)) i += 1 @@ -2169,8 +2166,7 @@ try: opts, args = getopt.getopt(OPTIONS, OPTIONSLIST) -except getopt.GetoptError as xxx_todo_changeme3: - (errmsg, badarg) = xxx_todo_changeme3.args +except getopt.GetoptError, (errmsg, badarg): ErrorMsg(eBADARG % errmsg) # Create and populate an object with rename targets. This must be diff --git a/tren2.py b/tren2.py deleted file mode 100755 index fb871e4..0000000 --- a/tren2.py +++ /dev/null @@ -1,2391 +0,0 @@ -#!/usr/bin/env python -# tren.py -# Copyright (c) 2010-2011 TundraWare Inc. -# For Updates See: http://www.tundraware.com/Software/tren - -# Program Information - -PROGNAME = "tren.py" -BASENAME = PROGNAME.split(".py")[0] -PROGENV = BASENAME.upper() -INCLENV = PROGENV + "INCL" -RCSID = "$Id: tren.py,v 1.242 2011/08/01 18:07:17 tundra Exp $" -VERSION = RCSID.split()[2] - -# Copyright Information - -CPRT = "(c)" -DATE = "2010-2011" -OWNER = "TundraWare Inc." -RIGHTS = "All Rights Reserved." -COPYRIGHT = "Copyright %s %s, %s %s" % (CPRT, DATE, OWNER, RIGHTS) - -PROGVER = PROGNAME + " " + VERSION + (" - %s" % COPYRIGHT) -HOMEPAGE = "http://www.tundraware.com/Software/%s\n" % BASENAME - - - -#----------------------------------------------------------# -# Variables User Might Change # -#----------------------------------------------------------# - - - -#------------------- Nothing Below Here Should Need Changing ------------------# - - -#----------------------------------------------------------# -# Imports # -#----------------------------------------------------------# - -import copy -import getopt -import glob -import os -import random -import re -import shlex -from stat import * -import sys -import time - -##### -# Imports conditional on OS -##### - -# Set OS type - this allows us to trigger OS-specific code -# where needed. - -OSNAME = os.name -POSIX = False -WINDOWS = False - -if OSNAME == 'nt': - WINDOWS = True - -elif OSNAME == 'posix': - POSIX = True - -# Set up Windows-specific stuff - -if WINDOWS: - - # Try to load win32all stuff if it's available - - try: - from win32api import GetFileAttributes, GetComputerName - import win32con - from win32file import GetDriveType - from win32wnet import WNetGetUniversalName - from win32security import * - WIN32HOST = GetComputerName() - WIN32ALL = True - - except: - WIN32ALL = False - -# Set up Unix-specific stuff - -elif POSIX: - - # Get Unix password and group features - - import grp - import pwd - - -# Uh oh, this is not an OS we know about - -else: - sys.stderr.write("Unsupported Operating System! Aborting ...\n") - sys.exit(1) - - -#----------------------------------------------------------# -# Aliases & Redefinitions # -#----------------------------------------------------------# - - - -#----------------------------------------------------------# -# Constants & Literals # -#----------------------------------------------------------# - - -##### -# General Program Constants -##### - -MAXINCLUDES = 1000 # Maximum number of includes allowed - used to catch circular references -MAXNAMELEN = 255 # Maximum file or directory name length -MINNAMELEN = 1 # Minimum file or directory name length - -##### -# Message Formatting Constants -##### - -# Make sure these make sense: ProgramOptions[MAXLINELEN] > PADWIDTH + WRAPINDENT -# because of the way line conditioning/wrap works. - -PADCHAR = " " # Padding character -PADWIDTH = 30 # Column width -LSTPAD = 13 # Padding to use when dumping lists -WRAPINDENT = 8 # Extra indent on wrapped lines -MINLEN = PADWIDTH + WRAPINDENT + 1 # Minimum line length - - -##### -# Command Line Option Strings -##### - -# List all legal command line options that will be processed by getopt() later. -# We exclude -I here because it is parsed manually before the getopt() call. - -OPTIONSLIST = "A:abCcde:fhi:P:qR:r:S:T:tvw:Xx" # All legal command line options in getopt() format - - -##### -# Literals -##### - -ARROW = "--->" # Used for formatting renaming messages -ASKDOREST = "!" # Do rest of renaming without asking -ASKNO = "N" # Do not rename current file -ASKQUIT = "q" # Quit renaming all further files -ASKYES = "y" # Rename current file -COMMENT = "#" # Comment character in include files -DEFINST = 0 # Default replacement instance -DEFLEN = 80 # Default output line length -DEFSEP = "=" # Default rename command separator: old=new -DEFSUFFIX = ".backup" # String used to rename existing targets -DEFESC = "\\" # Escape character -INCL = "I" # Include file command line option -INDENT = " " # Indent string for nested messages -NULLESC = "Escape string" # Cannot be null -NULLRENSEP = "Old/New separator string" # Cannot be null -NULLSUFFIX = "Forced renaming suffix string" # Cannot be null -OPTINTRO = "-" # Option introducer -PATHDELUNIX = ":" # Separates include path elements on Unix systems -PATHDELWIN = ";" # Separates include path elements on Windows systems -PATHSEP = os.path.sep # File path separator character -RANGESEP = ":" # Separator for instance ranges -SINGLEINST = "SINGLEINST" # Indicates a single, not range, in a slice -WINDOWSGROUP = "WindowsGroup" # Returned on Windows w/o win32all -WINDOWSUSER = "WindowsUser" # Reutrned on Windows w/o win32all -WINGROUPNOT = "GroupNotAvailable" # Returned when win32all can't get a group name -WINUSERNOT = "UserNotAvailable" # Returned when win32all can't get a user name - -##### -# Replacement Token Literals -##### - -# Sequence Alphabets - -BINARY = "Binary" -DECIMAL = "Decimal" -OCTAL = "Octal" -HEXLOWER = "HexLower" -HEXUPPER = "HexUpper" -LOWER = "Lower" -LOWERUPPER = "LowerUpper" -UPPER = "Upper" -UPPERLOWER = "UpperLower" - -# General Literals - -ALPHADELIM = ":" # Delimits alphabet name in a Sequence renaming token -TOKDELIM = "/" # Delimiter for all renaming tokens - -# Shared File Attribute And Sequence Renaming Tokens - -TOKFILADATE = "ADATE" -TOKFILATIME = "ATIME" -TOKFILCMD = "CMDLINE" -TOKFILCDATE = "CDATE" -TOKFILCTIME = "CTIME" -TOKFILDEV = "DEV" -TOKFILFNAME = "FNAME" -TOKFILGID = "GID" -TOKFILGROUP = "GROUP" -TOKFILINODE = "INODE" -TOKFILMODE = "MODE" -TOKFILMDATE = "MDATE" -TOKFILMTIME = "MTIME" -TOKFILNLINK = "NLINK" -TOKFILSIZE = "SIZE" -TOKFILUID = "UID" -TOKFILUSER = "USER" - -# File Time Renaming Tokens - -TOKADAY = "ADAY" # mm replacement token -TOKAHOUR = "AHOUR" # hh replacement token -TOKAMIN = "AMIN" # mm replacement token -TOKAMON = "AMON" # MM replacement token -TOKAMONTH = "AMONTH" # Mmm replacement token -TOKASEC = "ASEC" # ss replacement token -TOKAWDAY = "AWDAY" # Ddd replacement token -TOKAYEAR = "AYEAR" # yyyy replacement token - -TOKCDAY = "CDAY" # mm replacement token -TOKCHOUR = "CHOUR" # hh replacement token -TOKCMIN = "CMIN" # mm replacement token -TOKCMON = "CMON" # MM replacement token -TOKCMONTH = "CMONTH" # Mmm replacement token -TOKCSEC = "CSEC" # ss replacement token -TOKCWDAY = "CWDAY" # Ddd replacement token -TOKCYEAR = "CYEAR" # yyyy replacement token - -TOKMDAY = "MDAY" # mm replacement token -TOKMHOUR = "MHOUR" # hh replacement token -TOKMMIN = "MMIN" # mm replacement token -TOKMMON = "MMON" # MM replacement token -TOKMMONTH = "MMONTH" # Mmm replacement token -TOKMSEC = "MSEC" # ss replacement token -TOKMWDAY = "MWDAY" # Ddd replacement token -TOKMYEAR = "MYEAR" # yyyy replacement token - -# System Renaming Tokens - -TOKCMDEXEC = "`" # Delimiter for command execution renaming tokens -TOKENV = "$" # Introducer for environment variable replacement tokens -TOKRAND = "RAND" # Random replacement token -TOKNAMESOFAR = "NAMESOFAR" # New name so far - -# Sequence Renaming Tokens - -TOKASCEND = "+" # Ascending order flag -TOKDESCEND = "-" # Descending order flag - - -##### -# Internal program state literals -##### - -ASK = "ASK" -BACKUPS = "BACKUPS" -DEBUG = "DEBUG" -CASECONV = "CASECONV" -CASESENSITIVE = "CASESENSITIVE" -ESCAPE = "ESCAPE" -EXISTSUFFIX = "EXISTSUFFIX" -FORCERENAME = "FORCERENAME" -INSTANCESTART = "INSTANCESTART" -INSTANCEEND = "INSTANCEEND" -MAXLINELEN = "MAXLINELEN" -QUIET = "QUIET" -REGEX = "REGEX" -RENSEP = "RENSEP" -TARGETSTART = "TARGETSTART" -TARGETEND = "TARGETEND" -TESTMODE = "TESTMODE" - - -##### -# Renaming Literals -##### - -# Rename target keys - -BASE = "BASENAME" -PATHNAME = "PATHNAME" -STATS = "STATS" - -# These literals serve two purposes: -# -# 1) They are used as the type indicator in a Sequence Renaming Token -# 2) They are keys to the SortViews and DateViews dictionaries that stores the prestorted views - -ORDERBYADATE = TOKFILADATE -ORDERBYATIME = TOKFILATIME -ORDERBYCMDLINE = TOKFILCMD -ORDERBYCDATE = TOKFILCDATE -ORDERBYCTIME = TOKFILCTIME -ORDERBYDEV = TOKFILDEV -ORDERBYFNAME = TOKFILFNAME -ORDERBYGID = TOKFILGID -ORDERBYGROUP = TOKFILGROUP -ORDERBYINODE = TOKFILINODE -ORDERBYMODE = TOKFILMODE -ORDERBYMDATE = TOKFILMDATE -ORDERBYMTIME = TOKFILMTIME -ORDERBYNLINK = TOKFILNLINK -ORDERBYSIZE = TOKFILSIZE -ORDERBYUID = TOKFILUID -ORDERBYUSER = TOKFILUSER - -# Rename string keys - -NEW = "NEW" -OLD = "OLD" - - -#----------------------------------------------------------# -# Prompts, & Application Strings # -#----------------------------------------------------------# - - -##### -# Debug Messages -##### - -DEBUGFLAG = "-d" -dALPHABETS = "Alphabets" -dCMDLINE = "Command Line" -dCURSTATE = "Current State Of Program Options" -dDATEVIEW = "Date View:" -dDEBUG = "DEBUG" -dDUMPOBJ = "Dumping Object %s" -dINCLFILES = "Included Files:" -dPROGENV = "$" + PROGENV -dRENREQ = "Renaming Request:" -dRENSEQ = "Renaming Sequence: %s" -dRENTARGET = "Rename Target:" -dRESOLVEDOPTS = "Resolved Command Line" -dSEPCHAR = "-" # Used for debug separator lines -dSORTVIEW = "Sort View:" - - -##### -# Error Messages -##### - -eALPHABETEXIST = "Sequence renaming token '%s' specifies a non-existent alphabet!" -eALPHABETMISSING = "Sequence renaming token '%s' has a missing or incorrect alphabet specification!" -eALPHACMDBAD = "Alphabet specificaton '%s' malformed! Try \"Name:Alphabet\"" -eALPHACMDLEN = "Alphabet '%s' too short! Must contain at least 2 symbols." -eARGLENGTH = "%s must contain exactly %s character(s)!" -eBADARG = "Invalid command line: %s!" -eBADCASECONV = "Invalid case conversion argument: %s! Must be one of: %s" -eBADINCL = "option -%s requires argument" % INCL -eBADLEN = "Bad line length '%s'!" -eBADNEWOLD = "Bad -r argument '%s'! Requires exactly one new, old string separator (Default: " + DEFSEP + ")" -eBADREGEX = "Invalid Regular Expression: %s" -eBADSLICE = "%s invalid slice format! Must be integer values in the form: n, :n, n:, start:end, or :" -eERROR = "ERROR" -eEXECFAIL = "Renaming token: '%s', command '%s' Failed To Execute!" -eFILEOPEN = "Cannot open file '%s': %s!" -eLINELEN = "Specified line length too short! Must be at least %s" % MINLEN -eNAMELONG = "Renaming '%s' to new name '%s' too long! (Maximum length is %s.)" -eNAMESHORT = "Renaming '%s' to new name '%s' too short! (Minimum length is %s.)" -eNOROOTRENAME = "Cannot rename root of file tree!" -eNULLARG = "%s cannot be empty!" -eRENAMEFAIL = "Attempt to rename '%s' to '%s' failed : %s!" -eTOKBADSEQ = "Unknown sequence renaming token, '%s'!" -eTOKDELIM = "Renaming token '%s' missing delimiter!" -eTOKRANDIG = "Renaming token: '%s' has invalid random precision! Must be integer > 0." -eTOKUNKNOWN = "Unknown renaming token, '%s'!" -eTOOMANYINC = "Too many includes! (Max is %d) Possible circular reference?" % MAXINCLUDES - - -##### -# Informational Messages -##### - -iFORCEDNOBKU = "Forced renaming WITHOUT backups in effect!!! %s is overwriting %s." -iRENFORCED = "Target '%s' exists. Creating backup." -iRENSKIPPED = "Target '%s' exists. Renaming '%s' skipped." -iRENAMING = "Renaming '%s' " + ARROW + " '%s'" -iSEQTOOLONG = "Sequence number %s, longer than format string %s, Rolling over!" - - -##### -# Usage Prompts -##### - -uTable = [PROGVER, - HOMEPAGE, - "usage: " + PROGNAME + " [-abCcdfhqtvwXx] [-e type] [-I file] [-i instance] [-P escape] [ -R separator] [-r old=new] [-S suffix] [-T target] [-w width] ... file|dir file|dir ...", - " where,", - " -A alphabet Install \"alphabet\" for use by sequence renaming tokens", - " -a Ask interactively before renaming (Default: Off)", - " -b Turn off backups during forced renaming (Default: Do Backups)", - " -C Do case-sensitive renaming (Default)", - " -c Collapse case when doing string substitution (Default: False)", - " -d Dump debugging information (Default: False)", - " -e type Force case conversion (Default: None)", - " -f Force renaming even if target file or directory name already exists (Default: False)", - " -h Print help information (Default: False)", - " -I file Include command line arguments from file", - " -i num|range Specify which instance(s) to replace (Default: %s)" % DEFINST, - " -P char Use 'char' as the escape sequence (Default: %s)" % DEFESC, - " -q Quiet mode, do not show progress (Default: False)", - " -R char Separator character for -r rename arguments (Default: %s)" % DEFSEP, - " -r old=new Replace old with new in file or directory names", - " -S suffix Suffix to use when renaming existing filenames (Default: %s)" % DEFSUFFIX, - " -t Test mode, don't rename, just show what the program *would* do (Default: False)", - " -T num|range Specify which characters in file name are targeted for renaming (Default: Whole Name)", - " -v Print detailed program version information and continue (Default: False)", - " -w length Line length of diagnostic and error output (Default: %s)" % DEFLEN, - " -X Treat the renaming strings literally (Default)", - " -x Treat the old replacement string as a Python regular expression (Default: False)", - ] - - -#----------------------------------------------------------# -# Lookup Tables # -#----------------------------------------------------------# - - -# Case Conversion - - -# Notice use of *unbound* string function methods from the class definition - -CASETBL = {'c' : str.capitalize, - 'l' : str.lower, - 's' : str.swapcase, - 't' : str.title, - 'u' : str.upper - } - -CASEOPS = CASETBL.keys() -CASEOPS.sort() - - -# Day And Month Conversion Tables - - -DAYS = {0:"Mon", 1:"Tue", 2:"Wed", 3:"Thu", 4:"Fri", 5:"Sat", 6:"Sun"} - -MONTHS = {1:"Jan", 2:"Feb", 3:"Mar", 4:"Apr", 5:"May", 6:"Jun", - 7:"Jul", 8:"Aug", 9:"Sep", 10:"Oct", 11:"Nov", 12:"Dec"} - -# File Time Renaming Token Lookup Table - -FILETIMETOKS = { TOKADAY : ("%02d", "ST_ATIME", "tm_mday"), - TOKAHOUR : ("%02d", "ST_ATIME", "tm_hour"), - TOKAMIN : ("%02d", "ST_ATIME", "tm_min"), - TOKAMON : ("%02d", "ST_ATIME", "tm_mon"), - TOKAMONTH : ("", "ST_ATIME", "tm_mon"), - TOKASEC : ("%02d", "ST_ATIME", "tm_sec"), - TOKAWDAY : ("", "ST_ATIME", "tm_wday"), - TOKAYEAR : ("%04d", "ST_ATIME", "tm_year"), - TOKCDAY : ("%02d", "ST_CTIME", "tm_mday"), - TOKCHOUR : ("%02d", "ST_CTIME", "tm_hour"), - TOKCMIN : ("%02d", "ST_CTIME", "tm_min"), - TOKCMON : ("%02d", "ST_CTIME", "tm_mon"), - TOKCMONTH : ("", "ST_CTIME", "tm_mon"), - TOKCSEC : ("%02d", "ST_CTIME", "tm_sec"), - TOKCWDAY : ("", "ST_CTIME", "tm_wday"), - TOKCYEAR : ("%04d", "ST_CTIME", "tm_year"), - TOKMDAY : ("%02d", "ST_MTIME", "tm_mday"), - TOKMHOUR : ("%02d", "ST_MTIME", "tm_hour"), - TOKMMIN : ("%02d", "ST_MTIME", "tm_min"), - TOKMMON : ("%02d", "ST_MTIME", "tm_mon"), - TOKMMONTH : ("", "ST_MTIME", "tm_mon"), - TOKMSEC : ("%02d", "ST_MTIME", "tm_sec"), - TOKMWDAY : ("", "ST_MTIME", "tm_wday"), - TOKMYEAR : ("%04d", "ST_MTIME", "tm_year") - } - -# Alphabets - The user can add to these on the command line - -ALPHABETS = { - - BINARY : ["0", "1"], - - DECIMAL : ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"], - - HEXLOWER : ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"], - - HEXUPPER : ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"], - - LOWER : ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", - "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" ], - - LOWERUPPER : ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", - "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", "E", "F", - "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", - "W", "X", "Y", "Z"], - - OCTAL : ["0", "1", "2", "3", "4", "5", "6", "7"], - - UPPER : ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", - "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" ], - - UPPERLOWER : ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", - "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", - "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", - "w", "x", "y", "z"] - } - - - - -#----------------------------------------------------------# -# Global Variables & Data Structures # -#----------------------------------------------------------# - -# List of all the included files - -IncludedFiles = [] - - -# Program toggle and option defaults - -ProgramOptions = { - ASK : False, # Interactively ask user before renaming each file - BACKUPS : True, # Do backups during forced renaming - DEBUG : False, # Debugging off - CASECONV : None, # Forced case conversions - CASESENSITIVE : True, # Search is case-sensitive - ESCAPE : DEFESC, # Escape string - EXISTSUFFIX : DEFSUFFIX, # What to tack on when renaming existing targets - FORCERENAME : False, # Do not rename if target already exists - INSTANCESTART : DEFINST, # Replace first, leftmost instance by default - INSTANCEEND : SINGLEINST, - MAXLINELEN : DEFLEN, # Width of output messages - QUIET : False, # Display progress - REGEX : False, # Do not treat old string as a regex - RENSEP : DEFSEP, # Old, New string separator for -r - TARGETSTART : False, # Entire file name is renaming target by default - TARGETEND : False, - TESTMODE : False # Test mode off - } - - -# Used to track the sequence of name transformations as each renaming -# request is applied. The -1th entry is thus also the "name so far" -# used for the /NAMESOFAR/ renaming token. - -RenSequence = [] - -#--------------------------- Code Begins Here ---------------------------------# - - -#----------------------------------------------------------# -# Object Base Class Definitions # -#----------------------------------------------------------# - - -##### -# Container For Holding Rename Targets And Renaming Requests -##### - -class RenameTargets: - - """ - This class is used to keep track of all the files and/or - directories we're renaming. After the class is constructed - and the command line fully parsed, this will contain: - - self.RenNames = { fullname : {BASE : basename, PATHNAME : pathtofile, STATS : stats} - ... (repeated for each rename target) - } - - self.SortViews = { - ORDERBYATIME : [fullnames in atimes order], - ORDERBYCMDLINE : [fullnames in command line order], - ORDERBYCTIME : [fullnames in ctimes order], - ORDERBYDEV : [fullnames in devs order], - ORDERBYFNAME : [fullnames in alphabetic order], - ORDERBYGID : [fullnames in gids order], - ORDERBYGROUP ; [fullnames in group name order], - ORDERBYINODE : [fullnames in inode order], - ORDERBYMODE : [fullnames in mode order], - ORDERBYMTIME : [fullnames in mtimes order], - ORDERBYNLINK : [fullnames in nlinks order], - ORDERBYSIZE : [fullnames in size order], - ORDERBYUID : [fullnames in uids order], - ORDERBYUSER : [fullnames in user name order] - } - - self.DateViews = { - ORDERBYADATE-date... : [fullnames in order by atime within same 'date'] ... (repeated for each date), - ORDERBYCDATE-date... : [fullnames in order by ctime within same 'date'] ... (repeated for each date), - ORDERBYMDATE-date... : [fullnames in order by mtime within same 'date'] ... (repeated for each date) - } - - self.RenRequests = [ - { - ASK : interactive ask flag - BACKUPS : do backups during forced renaming flag, - OLD : old rename string, - NEW : new rename string, - DEBUG : debug flag, - CASECONV : type of case conversion, - CASESENSITIVE : case sensitivity flag, - FORCERENAME : force renaming flag, - INSTANCESTART : Replace first, leftmost instance by default, - INSTANCEEND : , - MAXLINELEN : max output line length, - QUIET : quiet output flag, - REGEX : regular expression enable flag, - RENSEP : old/new rename separator string, - TARGETSTART : Entire file name target for renaming by default, - TARGETEND : , - TESTMODE : testmode flag - } ... (repeated for each rename request) - ] - - """ - - ##### - # Constructor - ##### - - def __init__(self, targs): - - # Keep track of all the new filenames we write (or would have) - # so test mode can correctly report just what the the progam - # *would* do. Without this, backup generation is not properly - # reported in test mode. - - self.RenamedFiles = [] - self.NewFiles = [] - - # Dictionary of all rename targets and their stat info - - self.RenNames = {} - - # Dictionary of all possible sort views - # We can load the first two right away since they're based - # only on the target names provided on the command line - - i=0 - while i < len(targs): - targs[i] = os.path.abspath(targs[i]) - i += 1 - - alpha = targs[:] - alpha.sort() - self.SortViews = {ORDERBYCMDLINE : targs, ORDERBYFNAME : alpha} - del alpha - - # Dictionary to hold all possible date views - files sorted - # by time *within* a common date. - - self.DateViews = {} - - # Dictionary of all the renaming requests - will be filled in - # by -r command line parsing. - - self.RenRequests = [] - - - # This data structure is used to build various sort views - # A null first field means the view requires special handling, - # otherwise it's just a stat structure lookup. - - SeqTypes = [ - [ST_ATIME, {}, ORDERBYATIME], - [ST_CTIME, {}, ORDERBYCTIME], - [ST_DEV, {}, ORDERBYDEV], - [ST_GID, {}, ORDERBYGID], - ["", {}, ORDERBYGROUP], - [ST_INO, {}, ORDERBYINODE], - [ST_MODE, {}, ORDERBYMODE], - [ST_MTIME, {}, ORDERBYMTIME], - [ST_NLINK, {}, ORDERBYNLINK], - [ST_SIZE, {}, ORDERBYSIZE], - [ST_UID, {}, ORDERBYUID], - ["", {}, ORDERBYUSER], - ] - - # Populate the data structures with each targets' stat information - - for fullname in targs: - - try: - pathname, basename = os.path.split(fullname) - stats = os.stat(fullname) - except (IOError, OSError), (errno, errstr): - ErrorMsg(eFILEOPEN % (fullname, errstr)) - - # Some operating systems (Windows) terminate the path with - # a separator, some (Posix) do not. - - if pathname[-1] != os.sep: - pathname += os.sep - - # Store fullname, basename, and stat info for this file - - if basename: - self.RenNames[fullname] = {BASE : basename, PATHNAME : pathname, STATS : stats} - - # Catch the case where they're trying to rename the root of the directory tree - - else: - ErrorMsg(eNOROOTRENAME) - - # Incrementally build lists of keys that will later be - # used to create sequence renaming tokens - - for seqtype in SeqTypes: - - statflag, storage, order = seqtype - - # Handle os.stat() values - - if statflag: - sortkey = stats[statflag] - - # Handle group name values - - elif order == ORDERBYGROUP: - sortkey = self.__GetFileGroupname(fullname) - - # Handle user name values - - elif order == ORDERBYUSER: - sortkey = self.__GetFileUsername(fullname) - - # Save into storage - - if sortkey in storage: - storage[sortkey].append(fullname) - else: - storage[sortkey] = [fullname] - - - # Create the various sorted views we may need for sequence - # renaming tokens - - for seqtype in SeqTypes: - - statflag, storage, order = seqtype - - vieworder = storage.keys() - vieworder.sort() - - # Sort alphabetically when multiple filenames - # map to the same key, creating overall - # ordering as we go. - - t = [] - for i in vieworder: - storage[i].sort() - for j in storage[i]: - t.append(j) - - # Now store for future reference - - self.SortViews[order] = t - - # Release the working data structures - - del SeqTypes - - # Now build the special cases of ordering by time within date - # for each of the timestamp types. - - for dateorder, timeorder, year, mon, day in ((ORDERBYADATE, ORDERBYATIME, - FILETIMETOKS[TOKAYEAR], - FILETIMETOKS[TOKAMON], - FILETIMETOKS[TOKADAY]), - - (ORDERBYCDATE, ORDERBYCTIME, - FILETIMETOKS[TOKCYEAR], - FILETIMETOKS[TOKCMON], - FILETIMETOKS[TOKCDAY]), - - (ORDERBYMDATE, ORDERBYMTIME, - FILETIMETOKS[TOKMYEAR], - FILETIMETOKS[TOKMMON], - FILETIMETOKS[TOKMDAY])): - - - lastdate = "" - for fullname in self.SortViews[timeorder]: - - targettime = eval("time.localtime(self.RenNames[fullname][STATS][%s])" % year[1]) - - newdate = year[0] % eval("targettime.%s" % year[2]) + \ - mon[0] % eval("targettime.%s" % mon[2]) + \ - day[0] % eval("targettime.%s" % day[2]) - - key = dateorder+newdate - - # New file date encountered - - if newdate != lastdate: - - self.DateViews[key] = [fullname] - lastdate = newdate - - # Add file to existing list of others sharing that date - - else: - self.DateViews[key].append(fullname) - - # End of '__init__()' - - - ##### - # Debug Dump - ##### - - def DumpObj(self): - - SEPARATOR = dSEPCHAR * ProgramOptions[MAXLINELEN] - DebugMsg("\n") - DebugMsg(SEPARATOR) - DebugMsg(dDUMPOBJ % str(self)) - DebugMsg(SEPARATOR) - - - # Dump the RenNames and SortView dictionaries - - for i, msg in ((self.RenNames, dRENTARGET), (self.SortViews, dSORTVIEW), (self.DateViews, dDATEVIEW)): - - for j in i: - DumpList(msg, j, i[j]) - - for rr in self.RenRequests: - DumpList(dRENREQ, "", rr) - - DebugMsg(SEPARATOR + "\n\n") - - # End of 'DumpObj()' - - - ##### - # Determine File's Group Name - ##### - - def __GetFileGroupname(self, fullname): - - if POSIX: - return grp.getgrgid(self.RenNames[fullname][STATS][ST_GID])[0] - - else: - retval = WINDOWSGROUP - - if WIN32ALL: - - try: - # Get the internal Win32 security group information for this file. - - hg = GetFileSecurity(fullname, GROUP_SECURITY_INFORMATION) - sidg = hg.GetSecurityDescriptorGroup() - - # We have to know who is hosting the filesystem for this file - - drive = fullname[0:3] - if GetDriveType(drive) == win32con.DRIVE_REMOTE: - fnhost = WNetGetUniversalName(drive, 1).split('\\')[2] - - else: - fnhost = WIN32HOST - - # Now we can translate the sids into names - - retval = LookupAccountSid(fnhost, sidg)[0] - - # On any error, just act like win32all isn't there - - except: - retval = WINGROUPNOT - - return retval - - # End of 'GetFileGroupname()' - - - ##### - # Determine File's User Name - ##### - - def __GetFileUsername(self, fullname): - - if POSIX: - return pwd.getpwuid(self.RenNames[fullname][STATS][ST_UID])[0] - - else: - retval = WINDOWSUSER - - if WIN32ALL: - - try: - - # Get the internal Win32 security information for this file. - - ho = GetFileSecurity(fullname, OWNER_SECURITY_INFORMATION) - sido = ho.GetSecurityDescriptorOwner() - - # We have to know who is hosting the filesystem for this file - - drive = fullname[0:3] - if GetDriveType(drive) == win32con.DRIVE_REMOTE: - fnhost = WNetGetUniversalName(drive, 1).split('\\')[2] - - else: - fnhost = WIN32HOST - - # Now we can translate the sids into names - - retval = LookupAccountSid(fnhost, sido)[0] - - # On any error, just act like win32all isn't there - - except: - retval = WINUSERNOT - - return retval - - # End of 'GetFileUsername()' - - - ##### - # Go Do The Requested Renaming - ##### - - def ProcessRenameRequests(self): - - global RenSequence - self.indentlevel = -1 - - # Create a list of all renaming to be done. - # This includes the renaming of any existing targets. - - for target in self.SortViews[ORDERBYCMDLINE]: - - oldname, pathname = self.RenNames[target][BASE], self.RenNames[target][PATHNAME] - newname = oldname - - # Keep track of incremental renaming for use by debug - RenSequence = [oldname] - - for renrequest in self.RenRequests: - - # Select portion of name targeted for renaming - - lname = "" - rname = "" - tstart = renrequest[TARGETSTART] - tend = renrequest[TARGETEND] - - # Condition values so that range slicing works properly below. - # This couldn't be done at the time the target range was - # saved intially, because the length of the name being processed - # isn't known until here. - - if tstart == None: - tstart = 0 - - if tend == None: - tend = len(newname) - - if tstart or tend: - - bound = len(newname) - - # Normalize negative refs so we can use consistent - # logic below - - if tstart < 0: - tstart = bound + tstart - - if (tend != SINGLEINST and tend < 0): - tend = bound + tend - - # Condition and bounds check the target range as needed - - # Handle single position references - if (tend == SINGLEINST): - - # Select the desired position. Notice that - # out-of-bounds references are ignored and the - # name is left untouched. This is so the user - # can specify renaming operations on file - # names of varying lengths and have them apply - # only to those files long enough to - # accommodate the request without blowing up - # on the ones that are not long enough. - - if 0 <= tstart < bound: - lname, newname, rname = newname[:tstart], newname[tstart], newname[tstart+1:] - - # Reference is out of bounds - leave name untouched - - else: - lname, newname, rname = newname, "", "" - - # Handle slice range requests - - else: - - # Out-Of-Bounds or invalid slice ranges will - # cause renaming request to be ignored as above - - if newname[tstart:tend]: - lname, newname, rname = newname[:tstart], newname[tstart:tend], newname[tend:] - - else: - lname, newname, rname = newname, "", "" - - - # Handle conventional string replacement renaming requests - # An empty newname here means that the -T argument processing - # selected a new string and/or was out of bounds -> we ignore the request. - - if newname and (renrequest[OLD] or renrequest[NEW]): - - # Resolve any embedded renaming tokens - - old = self.__ResolveRenameTokens(target, renrequest[OLD]) - new = self.__ResolveRenameTokens(target, renrequest[NEW]) - - oldstrings = [] - - # Build a list of indexes to every occurence of the old string, - # taking case sensitivity into account - - # Handle the case when old = "". This means to - # *replace the entire* old name with new. More - # specifically, replace the entire old name *as - # modified so far by preceding rename commands*. - - if not old: - old = newname - - # Find every instance of the 'old' string in the - # current filename. 'Find' in this case can be either - # a regular expression pattern match or a literal - # string match. - # - # Either way, each 'hit' is recorded as a tuple: - # - # (index to beginning of hit, beginning of next non-hit text) - # - # This is so subsequent replacement logic knows: - # - # 1) Where the replacement begins - # 2) Where the replacement ends - # - # These two values are used during actual string - # replacement to properly replace the 'new' string - # into the requested locations. - - - # Handle regular expression pattern matching - - if renrequest[REGEX]: - - try: - # Do the match either case-insentitive or not - - if renrequest[CASESENSITIVE]: - rematches = re.finditer(old, newname) - - else: - rematches = re.finditer(old, newname, re.I) - - # And save off the results - - for match in rematches: - oldstrings.append(match.span()) - - except: - ErrorMsg(eBADREGEX % old) - - # Handle literal string replacement - - else: - - searchtarget = newname - - # Collapse case if requested - - if not renrequest[CASESENSITIVE]: - - searchtarget = searchtarget.lower() - old = old.lower() - - oldlen = len(old) - i = searchtarget.find(old) - while i >= 0: - - nextloc = i + oldlen - oldstrings.append((i, nextloc)) - i = searchtarget.find(old, nextloc) - - # If we found any matching strings, replace them - - if oldstrings: - - # But only process the instances the user asked for - - todo = [] - - # Handle single instance requests doing bounds checking as we go - - start = renrequest[INSTANCESTART] - end = renrequest[INSTANCEEND] - - if (end == SINGLEINST): - - # Compute bounds for positive and negative indicies. - # This is necessary because positive indicies are 0-based, - # but negative indicies start at -1. - - bound = len(oldstrings) - - if start < 0: - bound += 1 - - # Now go get that entry - - if abs(start) < bound: - todo.append(oldstrings[start]) - - # Handle instance range requests - - else: - todo = oldstrings[start:end] - - - # Replace selected substring(s). Substitute from - # R->L in original string so as not to mess up the - # replacement indicies. - - todo.reverse() - for i in todo: - newname = newname[:i[0]] + new + newname[i[1]:] - - - # Handle case conversion renaming requests - - elif renrequest[CASECONV]: - newname = CASETBL[renrequest[CASECONV]](newname) - - # Any subsequent replacements operate on the modified name - # which is reconstructed by combining what we've renamed - # with anything that was excluded from the rename operation. - - newname = lname + newname + rname - - # Keep track of incremental renaming for use by debug - RenSequence.append(newname) - - # Show the incremental renaming steps if debug is on - - if ProgramOptions[DEBUG]: - DebugMsg(dRENSEQ % ARROW.join(RenSequence)) - - # Nothing to do, if old- and new names are the same - - if newname != oldname: - self.__RenameIt(pathname, oldname, newname) - - # End of 'ProcessRenameRequests()' - - - ##### - # Actually Rename A File - ##### - - def __RenameIt(self, pathname, oldname, newname): - - self.indentlevel += 1 - indent = self.indentlevel * INDENT - newlen = len(newname) - - # First make sure the new name meets length constraints - - if newlen < MINNAMELEN: - ErrorMsg(indent + eNAMESHORT% (oldname, newname, MINNAMELEN)) - return - - if newlen > MAXNAMELEN: - ErrorMsg(indent + eNAMELONG % (oldname, newname, MAXNAMELEN)) - return - - # Get names into absolute path form - - fullold = pathname + oldname - fullnew = pathname + newname - - # See if our proposed renaming is about to stomp on an - # existing file, and create a backup if forced renaming - # requested. We do such backups with a recursive call to - # ourselves so that filename length limits are observed and - # backups-of-backups are preserved. - - doit = True - newexists = os.path.exists(fullnew) - - if (not ProgramOptions[TESTMODE] and newexists) or \ - (ProgramOptions[TESTMODE] and fullnew not in self.RenamedFiles and (newexists or fullnew in self.NewFiles)): - - if ProgramOptions[FORCERENAME]: - - # Create the backup unless we've been told not to - - if ProgramOptions[BACKUPS]: - - bkuname = newname + ProgramOptions[EXISTSUFFIX] - InfoMsg(indent + iRENFORCED % fullnew) - self.__RenameIt(pathname, newname, bkuname) - - else: - InfoMsg(iFORCEDNOBKU % (fullold, fullnew)) - - else: - InfoMsg(indent + iRENSKIPPED % (fullnew, fullold)) - doit = False - - if doit: - - if ProgramOptions[ASK]: - - answer = "" - while answer.lower() not in [ASKNO.lower(), ASKYES.lower(), ASKDOREST.lower(), ASKQUIT.lower()]: - - PrintStdout("Rename %s to %s? [%s]: " % (fullold, fullnew, ASKNO+ASKYES+ASKDOREST+ASKQUIT), TRAILING="") - - answer = sys.stdin.readline().lower().strip() - - # A blank line means take the default - do nothing. - - if not answer: - answer = ASKNO.lower() - - if answer == ASKNO.lower(): - doit = False - - if answer == ASKYES.lower(): - doit = True - - if answer == ASKDOREST.lower(): - doit = True - ProgramOptions[ASK] = False - - if answer == ASKQUIT.lower(): - sys.exit(1) - - if doit: - - # In test mode, track file names that would be produced. - - if ProgramOptions[TESTMODE]: - - self.NewFiles.append(fullnew) - self.RenamedFiles.append(fullold) - - if fullold in self.NewFiles: - self.NewFiles.remove(fullold) - - if fullnew in self.RenamedFiles: - self.RenamedFiles.remove(fullnew) - - InfoMsg(indent + iRENAMING % (fullold, fullnew)) - - if not ProgramOptions[TESTMODE]: - - try: - os.rename(fullold, fullnew) - except OSError, (errno, errstr): - ErrorMsg(eRENAMEFAIL % (fullold, fullnew, errstr)) - - self.indentlevel -= 1 - - # End of '__RenameIt()' - - - ##### - # Resolve Rename Tokens - ##### - - """ This replaces all renaming token references in 'renstring' - with the appropriate content and returns the resolved string. - 'target' is the name of the current file being renamed. We - need that as well because some renaming tokens refer to file - stat attributes or even the file name itself. - """ - - def __ResolveRenameTokens(self, target, renstring): - - # Find all token delimiters but ignore any that might appear - # inside a command execution replacement token string. - - rentokens = [] - odd = True - incmdexec = False - - i=0 - while i < len(renstring): - - if renstring[i] == TOKCMDEXEC: - incmdexec = not incmdexec - - elif renstring[i] == TOKDELIM: - - if incmdexec: - pass - - elif odd: - - rentokens.append([i]) - odd = not odd - - else: - - rentokens[-1].append(i) - odd = not odd - - - i += 1 - - # There must be an even number of token delimiters - # or the renaming token is malformed - - if rentokens and len(rentokens[-1]) != 2: - ErrorMsg(eTOKDELIM % renstring) - - # Now add the renaming token contents. This will be used to - # figure out what the replacement text should be. - - i = 0 - while i < len(rentokens): - - rentokens[i].append(renstring[rentokens[i][0]+1 : rentokens[i][1]]) - i += 1 - - # Process each token. Work left to right so as not to mess up - # the previously stored indexes. - - rentokens.reverse() - - for r in rentokens: - - fullrentoken = "%s%s%s" % (TOKDELIM, r[2], TOKDELIM) # Need this for error messages. - - ### - # File Attribute Renaming Tokens - ### - - if r[2] == TOKFILDEV: - r[2] = str(self.RenNames[target][STATS][ST_DEV]) - - elif r[2] == TOKFILFNAME: - r[2] = os.path.basename(target) - - elif r[2] == TOKFILGID: - r[2] = str(self.RenNames[target][STATS][ST_GID]) - - elif r[2] == TOKFILGROUP: - r[2] = self.__GetFileGroupname(target) - - elif r[2] == TOKFILINODE: - r[2] = str(self.RenNames[target][STATS][ST_INO]) - - elif r[2] == TOKFILMODE: - r[2] = str(self.RenNames[target][STATS][ST_MODE]) - - elif r[2] == TOKFILNLINK: - r[2] = str(self.RenNames[target][STATS][ST_NLINK]) - - elif r[2] == TOKFILSIZE: - r[2] = str(self.RenNames[target][STATS][ST_SIZE]) - - elif r[2] == TOKFILUID: - r[2] = str(self.RenNames[target][STATS][ST_UID]) - - elif r[2] == TOKFILUSER: - r[2] = self.__GetFileUsername(target) - - - ### - # File Time Renaming Tokens - ### - - elif r[2] in FILETIMETOKS: - - parms = FILETIMETOKS[r[2]] - val = eval("time.localtime(self.RenNames[target][STATS][%s]).%s" % (parms[1], parms[2])) - - # The first value of FILETIMETOKS table entry - # indicates the formatting string to use (if the entry - # is non null), or that we're doing a lookup for the - # name of a month (if the entry is null) - - if parms[0]: - r[2] = parms[0] % val - - elif parms[2] == "tm_mon": - r[2] = MONTHS[val] - - elif parms[2] == "tm_wday": - r[2] = DAYS[val] - - ### - # System Renaming Tokens - ### - - # Environment Variable replacement token - - elif r[2].startswith(TOKENV): - - r[2] = os.getenv(r[2][1:]) - - # Handle case for nonexistent environment variable - - if not r[2]: - r[2] = "" - - - # Command Run replacement token - - elif r[2].startswith(TOKCMDEXEC) and r[2].endswith(TOKCMDEXEC): - - command = r[2][1:-1] - - # Handle Windows variants - they act differently - - if not POSIX: - pipe = os.popen(command, 'r') - - # Handle Unix variants - - else: - pipe = os.popen('{ ' + command + '; } 2>&1', 'r') - - output = pipe.read() - status = pipe.close() - - if status == None: - status = 0 - - # Nonzero status means error attempting to execute the command - - if status: - ErrorMsg(eEXECFAIL % (fullrentoken, command)) - - # Otherwise swap the command with its results, stripping newlines - - else: - r[2] = output.replace("\n", "") - - - # Random Number Replacement token - - elif r[2].startswith(TOKRAND): - - random.seed() - - # Figure out how many digits of randomness the user want - - try: - precision = r[2].split(TOKRAND)[1] - precision = int(precision) - - except: - ErrorMsg(eTOKRANDIG % fullrentoken) - - if precision < 1: - ErrorMsg(eTOKRANDIG % fullrentoken) - - fmt = '"%0' + str(precision) + 'd" % random.randint(0, pow(10, precision)-1)' - r[2] = eval(fmt) - - # Name So Far Replacement Token - - elif r[2] == (TOKNAMESOFAR): - r[2] = RenSequence[-1] - - ### - # Sequence Renaming Tokens - ### - - elif r[2] and (r[2][0] == TOKASCEND or r[2][0] == TOKDESCEND): - - # Parse the Sequence Renaming Token into the token itself - # and its corresponding formatting field. - - # Note that the a legal Sequence Renaming Token will either - # be one of the keys of the SortViews dictionary or one - # of the "ORDERBYnDATE" orderings. - - token = r[2][1:] - - found = False - for seqtoken in self.SortViews.keys() + [ORDERBYADATE, ORDERBYCDATE, ORDERBYMDATE]: - - if token.split(ALPHADELIM)[0] == (seqtoken): - - token, field = token[:len(seqtoken)], token[len(seqtoken):] - found = True - break - - if not found: - ErrorMsg(eTOKBADSEQ % fullrentoken) - - # Now derive the name of the alphabet to use - - if not field.startswith(ALPHADELIM): - ErrorMsg(eALPHABETMISSING % fullrentoken) - - field = field[1:] - - alphabet, alphadelim, field = field.partition(ALPHADELIM) - - if not alphadelim: - ErrorMsg(eALPHABETMISSING % fullrentoken) - - # Empty alphabet string means default to decimal counting - - if not alphabet: - alphabet = DECIMAL - - if alphabet not in ALPHABETS: - ErrorMsg(eALPHABETEXIST % fullrentoken) - - - # Retrieve the ordered list of the requested type, - # adjust for descending order, and plug in the - # sequence number for the current renaming target - # (which is just the index of that filename in the - # list). - - # One of the standard sorted views requested - - if token in self.SortViews: - orderedlist = self.SortViews[token][:] - - # One of the views sorted within dates requested - - else: - - - if token == ORDERBYADATE: - year, mon, day = FILETIMETOKS[TOKAYEAR], FILETIMETOKS[TOKAMON], FILETIMETOKS[TOKADAY] - - elif token == ORDERBYCDATE: - year, mon, day = FILETIMETOKS[TOKCYEAR], FILETIMETOKS[TOKCMON], FILETIMETOKS[TOKCDAY] - - elif token == ORDERBYMDATE: - year, mon, day = FILETIMETOKS[TOKMYEAR], FILETIMETOKS[TOKMMON], FILETIMETOKS[TOKMDAY] - - targettime = eval("time.localtime(self.RenNames[target][STATS][%s])" % year[1]) - - key = token + \ - year[0] % eval("targettime.%s" % year[2]) + \ - mon[0] % eval("targettime.%s" % mon[2]) + \ - day[0] % eval("targettime.%s" % day[2]) - - orderedlist = self.DateViews[key][:] - - if r[2][0] == TOKDESCEND: - orderedlist.reverse() - - r[2] = ComputeSeqString(field, orderedlist.index(target), ALPHABETS[alphabet]) - - ### - # Unrecognized Renaming Token - ### - - else: - ErrorMsg(eTOKUNKNOWN % fullrentoken) - - ### - # Successful Lookup, Do the actual replacement - ### - - renstring = renstring[:r[0]] + r[2] + renstring[r[1]+1:] - - return renstring - - # End of '__ResolveRenameTokens()' - - -# End of class 'RenameTargets' - - -#----------------------------------------------------------# -# Supporting Function Definitions # -#----------------------------------------------------------# - - -##### -# Check For Correct Slice Syntax -##### - -def CheckSlice(val): - - try: - - # Process ranges - - if val.count(RANGESEP): - - lhs, rhs = val.split(RANGESEP) - - if not lhs: - lhs = None - - else: - lhs = int(lhs) - - if not rhs: - rhs = None - - else: - rhs = int(rhs) - - # Process single indexes - - else: - - lhs = int(val) - rhs = SINGLEINST - - # Something about the argument was bogus - - except: - ErrorMsg(eBADSLICE % val) - - return (lhs, rhs) - -# End Of 'CheckSlice()' - - -##### -# Turn A List Into Columns With Space Padding -##### - -def ColumnPad(list, PAD=PADCHAR, WIDTH=PADWIDTH): - - retval = "" - for l in list: - l = str(l) - retval += l + ((WIDTH - len(l)) * PAD) - - return retval - -# End of 'ColumnPad()' - - -def ComputeSeqString(fmt, incr, alphabet): - - """ - fmt = A literal "format field" string - incr = A integer to be "added" to the field - alphabet = The alphabet of characters to use, in ascending order - - Add 'incr' to 'fmt' in base(len(alphabet)). Characters in - 'fmt' that are not in 'alphabet' are ignored in this addition. - - The final result is limited to be no longer than 'fmt'. Any - result longer than fmt has MSD dropped, thereby effectively - rolling over the count. If 'fmt' is null on entry, the final - result length is unlimited. - """ - - base = len(alphabet) - - # Do position-wise "addition" via symbol substitution moving from - # right-to-left adjusting for the fact that not all symbols in the - # format string will be in the alphabet. - - - # First convert the increment into a string in the base of the - # alphabet - - idigits = [] - while incr > base-1: - - incr, digit = incr/base, incr % base - idigits.append(alphabet[digit]) - - idigits.append(alphabet[incr]) - idigits.reverse() - incr = "".join(idigits) - - # Now do right-to-left digit addition with the format - # field. - - # Do position-wise "addition" via symbol substitution moving from - # right-to-left. Take into account that the format pattern string - # may be a different length than the increment string and that not - # all characters in the format pattern are guaranteed to exist in - # the alphabet. - - newval = "" - carry = None - fmtlen = len(fmt) - incrlen = len(incr) - calcsize = max(fmtlen, incrlen) - - i = -1 - done = False - while abs(i) <= calcsize and not done: - - sum = 0 - - if carry: - sum += carry - - if fmt and (abs(i) <= fmtlen) and fmt[i] in alphabet: - sum += alphabet.index(fmt[i]) - - if abs(i) <= incrlen: - sum += alphabet.index(incr[i]) - - # Do arithmetic modulo alphabet length - - carry, digit = sum/base, sum % base - - if not carry: - carry = None - - # We're completely done if we're out of digits in incr and - # there's no carry to propagate. This prevents us from - # tacking on leading 0th characters which could overwrite - # out-of-alphabet characters in the format field. - - if abs(i-1) > incrlen: - done =True - - newval = alphabet[digit] + newval - - i -= 1 - - if carry: - newval = alphabet[carry] + newval - - # Constrain the results to the length of the original format - # string, rolling over and warning the user as necessary. The one - # exception to this is when a null format string is passed. This - # is understood to mean that sequences of any length are - # permitted. - - # Result length constrained by format string - - if fmtlen: - - if len(newval) > fmtlen: - InfoMsg(iSEQTOOLONG % (newval,fmt)) - newval = newval[-fmtlen:] - - return fmt[:-len(newval)] + newval - - # Any length result permitted - - else: - return newval - -# End of 'ComputeSeqString()' - - -##### -# Condition Line Length With Fancy Wrap And Formatting -##### - -def ConditionLine(msg, - PAD=PADCHAR, \ - WIDTH=PADWIDTH, \ - wrapindent=WRAPINDENT ): - - retval = [] - retval.append(msg[:ProgramOptions[MAXLINELEN]]) - msg = msg[ProgramOptions[MAXLINELEN]:] - - while msg: - msg = PAD * (WIDTH + wrapindent) + msg - retval.append(msg[:ProgramOptions[MAXLINELEN]]) - msg = msg[ProgramOptions[MAXLINELEN]:] - - return retval - -# End of 'ConditionLine()' - - -##### -# Print A Debug Message -##### - -def DebugMsg(msg): - - l = ConditionLine(msg) - for msg in l: - PrintStderr(PROGNAME + " " + dDEBUG + ": " + msg) - -# End of 'DebugMsg()' - - -##### -# Debug Dump Of A List -##### - -def DumpList(msg, listname, content): - - DebugMsg(msg) - itemarrow = ColumnPad([listname, " "], WIDTH=LSTPAD) - DebugMsg(ColumnPad([" ", " %s %s" % (itemarrow, content)])) - -# End of 'DumpList()' - - -##### -# Dump The State Of The Program -##### - -def DumpState(): - - SEPARATOR = dSEPCHAR * ProgramOptions[MAXLINELEN] - DebugMsg(SEPARATOR) - DebugMsg(dCURSTATE) - DebugMsg(SEPARATOR) - - opts = ProgramOptions.keys() - opts.sort() - for o in opts: - DebugMsg(ColumnPad([o, ProgramOptions[o]])) - - DumpList(dALPHABETS, "", ALPHABETS) - - DebugMsg(SEPARATOR) - - -# End of 'DumpState()' - - -##### -# Print An Error Message And Exit -##### - -def ErrorMsg(emsg): - - l = ConditionLine(emsg) - - for emsg in l: - PrintStderr(PROGNAME + " " + eERROR + ": " + emsg) - - sys.exit(1) - -# End of 'ErrorMsg()' - - -##### -# Split -r Argument Into Separate Old And New Strings -##### - -def GetOldNew(arg): - - - escaping = False - numseps = 0 - sepindex = 0 - oldnewsep = ProgramOptions[RENSEP] - - i = 0 - while i < len(arg): - - # Scan string ignoring escaped separators - - if arg[i:].startswith(oldnewsep): - - if (i > 0 and (arg[i-1] != ProgramOptions[ESCAPE])) or i == 0: - sepindex = i - numseps += 1 - - i += len(oldnewsep) - - else: - i += 1 - - - if numseps != 1: - ErrorMsg(eBADNEWOLD % arg) - - else: - old, new = arg[:sepindex], arg[sepindex + len(oldnewsep):] - old = old.replace(ProgramOptions[ESCAPE] + oldnewsep, oldnewsep) - new = new.replace(ProgramOptions[ESCAPE] + oldnewsep, oldnewsep) - return [old, new] - -# End of 'GetOldNew()' - - -##### -# Print An Informational Message -##### - -def InfoMsg(imsg): - - l = ConditionLine(imsg) - - msgtype = "" - if ProgramOptions[TESTMODE]: - msgtype = TESTMODE - - if not ProgramOptions[QUIET]: - for msg in l: - PrintStdout(PROGNAME + " " + msgtype + ": " + msg) - -# End of 'InfoMsg()' - - -##### -# Print To stderr -##### - -def PrintStderr(msg, TRAILING="\n"): - sys.stderr.write(msg + TRAILING) - -# End of 'PrintStderr()' - - -##### -# Print To stdout -##### - -def PrintStdout(msg, TRAILING="\n"): - sys.stdout.write(msg + TRAILING) - -# End of 'PrintStdout()' - - -##### -# Process Include Files On The Command Line -##### - -def ProcessIncludes(OPTIONS): - - """ Resolve include file references allowing for nested includes. - This has to be done here separate from the command line - options so that normal getopt() processing below will "see" - the included statements. - - This is a bit tricky because we have to handle every possible - legal command line syntax for option specification: - - -I filename - -Ifilename - -....I filename - -....Ifilename - """ - - # Build a list of all the options that take arguments. This is - # needed to determine whether the include symbol is an include - # option or part of an argument to a preceding option. - - OPTIONSWITHARGS = "" - for i in re.finditer(":", OPTIONSLIST): - OPTIONSWITHARGS += OPTIONSLIST[i.start() - 1] - - NUMINCLUDES = 0 - FoundNewInclude = True - - while FoundNewInclude: - - FoundNewInclude = False - i = 0 - while i < len(OPTIONS): - - # Detect all possible command line include constructs, - # isolating the requested filename and replaciing its - # contents at that position in the command line. - - field = OPTIONS[i] - position = field.find(INCL) - - if field.startswith(OPTINTRO) and (position > -1): - - - lhs = field[:position] - rhs = field[position+1:] - - # Make sure the include symbol isn't part of some - # previous option argument - - previousopt = False - for c in OPTIONSWITHARGS: - - if c in lhs: - - previousopt = True - break - - # If the include symbol appears in the context of a - # previous option, skip this field, otherwise process - # it as an include. - - - if not previousopt: - - FoundNewInclude = True - if lhs == OPTINTRO: - lhs = "" - - if rhs == "": - - if i < len(OPTIONS)-1: - - inclfile = OPTIONS[i+1] - OPTIONS = OPTIONS[:i+1] + OPTIONS[i+2:] - - # We have an include without a filename at the end - # of the command line which is bogus. - else: - ErrorMsg(eBADARG % eBADINCL) - - else: - inclfile = rhs - - # Before actually doing the include, make sure we've - # not exceeded the limit. This is here mostly to make - # sure we stop recursive/circular includes. - - NUMINCLUDES += 1 - if NUMINCLUDES > MAXINCLUDES: - ErrorMsg(eTOOMANYINC) - - # Read the included file, stripping out comments - - # Use include path if one was provided - - inclpath = os.getenv(INCLENV) - if inclpath: - - found = searchpath(inclfile, inclpath, PATHDEL) - if found: - inclfile = found[0] - - try: - n = [] - f = open(inclfile) - for line in f.readlines(): - line = line.split(COMMENT)[0] - n += shlex.split(line) - f.close() - - # Keep track of the filenames being included for debug output - - IncludedFiles.append(os.path.abspath(inclfile)) - - # Insert content of included file at current - # command line position - - # A non-null left hand side means that there were - # options before the include we need to preserve - - if lhs: - n = [lhs] + n - - OPTIONS = OPTIONS[:i] + n + OPTIONS[i+1:] - - except IOError, (errno, errstr): - ErrorMsg(eFILEOPEN % (inclfile, errstr)) - - i += 1 - - return OPTIONS - -# End of 'ProcessIncludes()' - - -##### -# Search Path Looking For Include File -##### - -def searchpath(filename, pathlist, pathdelim): - - # What we'll return if we find nothing - - retval = [] - - # Find all instances of filename in specified paths - - paths = pathlist.split(pathdelim) - - for path in paths: - - if path and path[-1] != PATHSEP: - path += PATHSEP - - path += filename - - if os.path.exists(path): - retval.append(os.path.realpath(path)) - - return retval - -# End of 'searchpath()' - - -##### -# Print Usage Information -##### - -def Usage(): - for line in uTable: - PrintStdout(line) - -# End of 'Usage()' - - -#----------------------------------------------------------# -# Program Entry Point # -#----------------------------------------------------------# - -# Set up proper include path delimiter - - -if WINDOWS: - PATHDEL = PATHDELWIN - -else: - PATHDEL = PATHDELUNIX - - -##### -# Command Line Preprocessing -# -# Some things have to be done *before* the command line -# options can actually be processed. This includes: -# -# 1) Prepending any options specified in the environment variable. -# -# 2) Resolving any include file references -# -# 3) Building the data structures that depend on the file/dir names -# specified for renaming. We have to do this first, because -# -r renaming operations specified on the command line will -# need this information if they make use of renaming tokens. -# -##### - -# Process any options set in the environment first, and then those -# given on the command line - - -OPTIONS = sys.argv[1:] - -envopt = os.getenv(PROGENV) -if envopt: - OPTIONS = shlex.split(envopt) + OPTIONS - -# Deal with include files - -OPTIONS = ProcessIncludes(OPTIONS) - -# And parse the command line - -try: - opts, args = getopt.getopt(OPTIONS, OPTIONSLIST) -except getopt.GetoptError, (errmsg, badarg): - ErrorMsg(eBADARG % errmsg) - -# Create and populate an object with rename targets. This must be -# done here because this object also stores the -r renaming requests -# we may find in the options processing below. Also, this object must -# be fully populated before any actual renaming can take place since -# many of the renaming tokens derive information about the file being -# renamed. - - -# Do wildcard expansion on the rename targets because they may -# have come from an include file (where they are not expanded) -# or from a Windows shell that doesn't know how to handle globbing -# properly. - -# If the glob expands to nothing, then supply the original string. -# That way an error will be thrown if either an explicitly named file -# does not exist, or if a wildcard expands to nothing. - -expandedlist = [] -for arg in args: - - wc = glob.glob(arg) - if wc: - expandedlist += wc - else: - expandedlist.append(arg) - -targs = RenameTargets(expandedlist) - -# Now process the options - -for opt, val in opts: - - # Install new alphabet - - if opt == "-A": - - alphaname, delim, alpha = val.partition(ALPHADELIM) - - if not delim: - ErrorMsg(eALPHACMDBAD % val) - - if not alphaname: - ErrorMsg(eALPHACMDBAD % val) - - if len(alpha) < 2: - ErrorMsg(eALPHACMDLEN % val) - - a = [] - for c in alpha: - a.append(c) - - ALPHABETS[alphaname] = a - - if opt == "-a": - ProgramOptions[ASK] = True - - # Turn off backups during forced renaming - - if opt == "-b": - ProgramOptions[BACKUPS] = False - - # Select case-sensitivity for replacements (or not) - - if opt == "-C": - ProgramOptions[CASESENSITIVE] = True - - if opt == "-c": - ProgramOptions[CASESENSITIVE] = False - - # Turn on debugging - - if opt == "-d": - ProgramOptions[DEBUG] = True - DumpState() - - # Force case conversion - - if opt == "-e": - - # Make sure we support the requested case conversion - if val in CASEOPS: - - ProgramOptions[CASECONV] = val - - # Construct a renaming request - - req = {} - req[OLD], req[NEW] = None, None - for opt in ProgramOptions: - req[opt] = ProgramOptions[opt] - - targs.RenRequests.append(req) - - # Error out if we don't recognize it - else: - ErrorMsg(eBADCASECONV % (val, ", ".join(CASEOPS))) - - - # Force renaming of existing targets - - if opt == "-f": - ProgramOptions[FORCERENAME] = True - - # Output usage information - - if opt == "-h": - Usage() - sys.exit(0) - - # Specify which instances to replace - - if opt == "-i": - - ProgramOptions[INSTANCESTART], ProgramOptions[INSTANCEEND] = CheckSlice(val) - - # Set the escape character - - if opt == "-P": - if len(val) == 1: - ProgramOptions[ESCAPE] = val - else: - ErrorMsg(eARGLENGTH % (NULLESC, 1)) - - # Set quiet mode - - if opt == "-q": - ProgramOptions[QUIET] = True - - # Set the separator character for replacement specifications - - if opt == '-R': - if len(val) == 1: - ProgramOptions[RENSEP] = val - else: - ErrorMsg(eARGLENGTH % (NULLRENSEP, 1)) - - # Specify a replacement command - - if opt == "-r": - req = {} - req[OLD], req[NEW] = GetOldNew(val) - ProgramOptions[CASECONV] = None - for opt in ProgramOptions: - req[opt] = ProgramOptions[opt] - targs.RenRequests.append(req) - - # Specify a renaming suffix - - if opt == "-S": - if val: - ProgramOptions[EXISTSUFFIX] = val - else: - ErrorMsg(eNULLARG % NULLSUFFIX) - - # Set substring targeted for renaming - - if opt == "-T": - ProgramOptions[TARGETSTART], ProgramOptions[TARGETEND] = CheckSlice(val) - - # Request test mode - - if opt == "-t": - ProgramOptions[TESTMODE] = True - - - # Output program version info - - if opt == "-v": - PrintStdout(RCSID) - - # Set output width - - if opt == "-w": - try: - l = int(val) - except: - ErrorMsg(eBADLEN % val) - if l < MINLEN: - ErrorMsg(eLINELEN) - ProgramOptions[MAXLINELEN] = l - - # Select whether 'old' replacement string is a regex or not - - if opt == "-X": - ProgramOptions[REGEX] = False - - if opt == "-x": - ProgramOptions[REGEX] = True - - -# At this point, the command line has been fully processed and the -# container fully populated. Provide debug info about both if -# requested. - -if ProgramOptions[DEBUG]: - - # Dump what we know about the command line - - DumpList(dCMDLINE, "", sys.argv) - DumpList(dPROGENV, "", envopt) - DumpList(dRESOLVEDOPTS, "", OPTIONS) - - # Dump what we know about included files - - DumpList(dINCLFILES, "", IncludedFiles) - - # Dump what we know about the container - - targs.DumpObj() - - -# Perform reqested renamings - -targs.ProcessRenameRequests() - - -# Release the target container if we created one - -del targs -