Good point Justin, thanks.
In an attempt to explain here is my reasoning:
[ operating system path module ] os.path.join()
-Easy to use and has a lot of catches
-One extra module import, meaning more need for traceability and logging and
such.
[ built-in function ] ‘/’.join
-Is built-in so traceability and extended knowledge requirements on my behalf
are None, this is just using python.
Example of how easy it is to have fun with joining things, paths or not:
" ".join(mylist)
{note the space}
" ".join(['Bob', 'Bobo', 'Bubba'])
(Note the addition if the square brackets inside the normal brackets.
Easy identification:
" <--> ".join(mylist())
Alphabetical
" ".join(sorted(mydict.keys()))
For every n in the list, do things to each one
print [ n for n in " ".join(sorted(mydict.keys())) ]
Filter
print [ n for n in " ".join(sorted(mydict.keys())) if "Bobo" in n]
But having said that I feel comfortable using the built-in join function in
this case as I know what I’m querying will always return a path in Windows form
or Unix style and all I’m doing is slicing the two elements together. For more
elaborate path joining depending on variable resolution and such I tend to
stick to os.path.join() as it has things in there that catch and construct
bespoke paths quite well. Can you throw me an example of how you would
approach the same scenario using the os.path module? If there are additional
catches and a compelling reason to use it I certainly will, just haven’t read
many cases where the path module is more useful than just simply joining things.
As for not using shutil, no real reason actually, got burnt on using it a few
times in the past so I tend to steer away from it, but it’s more of a personal
grief than anything technical, what it was being used for was odd so the module
itself is not really to blame I’d think. Do you have an example of how to use
shutil to ensure my backed up file is the same file as is in my scene
directory, anything other than a physical duplicate of the backed up file will
suffice I’d think as file size becomes an issue quite fast when working with
large files or working with a project off a small media.
I updated the code a little bit to add automatic versioning as well with a
prefix choice and cleaned up the path naming. My current issue is still that
once my file has been saved into the new directory and retains the original
name the file in the root of my scenes directory doesn’t update, as I mentioned
above and Justin suggests shutil should be able to sort this but as a side
gimmick does anyone know if Maya has any notion of multiple files being the
same file? As in save once , then build a representation of that file in
another location without it delaying the actual save process?
from os import listdir
from maya.cmds import file
from maya.cmds import workspace
class Backup( object ):
def __init__( self , foldername='' ):
"""Saves out an incremented backup file of your scene
-folder argument is the name of the folder the backed up file
gets saved into.
If no foldername is given a versioned file gets saved into the
root of the scenes directory.
"""
self.__version__ = '0.0.3'
self.foldername = foldername
def create_path( self , filerule='scene' , name=False ):
"""Creates a path within the current projects scene directory
-Use filerule to get the path of various workspace settings.
-Use the name argument as the name of the directory to create
"""
if not name:
name = self.foldername
scene = ''.join( [ workspace( q=1,rd=1 ) , workspace( filerule , q=1 ,
fre=1 ) ] )
self.path = '/'.join( [ scene , name ] )
workspace( create=self.path )
return self.path
def save( self , version=None , type='mayaBinary' , name='_noname_' ):
"""Places a saved out scene on disk
-Version argument adds that version name at the back of the scene
name.
-Type argument can be mayaBinary or mayaAscii
-Use name to set our scene name.
"""
path = self.create_path()
if not version:
version = self.get_version( path )
file( rename='%s %s' % ( '/'.join( [ path , name ] ) , version ) )
file( save=True , type=type )
file( rename=name )
return True
def get_version( self ,path , prefix='v' , initialversion='001' ):
"""Returns a valid version number for a given path
-Use the prefix argument to set a prepended name on your
version ID.
-initialversion can be used to state a version number to start
from if the backup directory is empty.
"""
backups = sorted( [ n for n in listdir( path ) ] )
if backups==[]:
return ''.join( [ prefix , initialversion ] )
else:
last_backup = backups[-1]
ver = [ n[ 1: ].split( '.' )[ 0 ] for n in last_backup.split()
if n.startswith( 'v' ) ][0]
new = ''.join( [ prefix , str( int( ver ) + 1 ).zfill( 3 ) ] )
return new
if __name__ == '__main__':
__oo__ = Backup( foldername='Backups' )
__oo__.save( name='Porks Werfect' )
Comments and discussion of course welcome
p.s. will learn how pastebin works before this gets any longer :)
--
You received this message because you are subscribed to the Google Groups
"Python Programming for Autodesk Maya" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
For more options, visit https://groups.google.com/groups/opt_out.
