Exemple #1
0
def backup(path, suffix='.bak'):
    """
    Rename a file or directory safely without overwriting an existing
    backup of the same name.

    :param path: The path object to the file or directory to make a backup of.
    :param suffix: The suffix to rename files with.
    :returns: The new path of backed up file/directory
    :rtype: str

    """
    count = -1
    new_path = None
    while True:
        if path.exists() :
            if count == -1:
                new_path = Path("{0}{1}".format(path, suffix))
            else:
                new_path = Path("{0}{1}.{2}".format(path, suffix, count))
            if new_path.exists():
                count += 1
                continue
            else:
                path.copy(new_path)
        else:
            break
    return new_path
Exemple #2
0
def backup(path, suffix='.bak'):
    """
    Rename a file or directory safely without overwriting an existing
    backup of the same name.

    :param path: The path object to the file or directory to make a backup of.
    :param suffix: The suffix to rename files with.
    :returns: The new path of backed up file/directory
    :rtype: str

    """
    count = -1
    new_path = None
    while True:
        if path.exists() :
            if count == -1:
                new_path = Path("{0}{1}".format(path, suffix))
            else:
                new_path = Path("{0}{1}.{2}".format(path, suffix, count))
            if new_path.exists():
                count += 1
                continue
            else:
                path.copy(new_path)
        else:
            break
    return new_path
Exemple #3
0
 def uploadFile(self, srcPath, destPath):
     db = self.getClient()
     srcPath = Path(srcPath)
     destPath = Path(destPath)
     destPath.makedirs()
     if srcPath.exists():
         result = db.put_file(destPath, open(srcPath,'rb'))
         return result
     return None
Exemple #4
0
def download_file(url, local_dir=None):
    url_file_name = Path(urlsplit(url)[2]).name
    if local_dir is None:
        local_dir = apiUtils.getTempDir()
    url_local_path = Path(local_dir).join(url_file_name)
    fullurl = urllib.parse.quote(url, safe="%/:=&?~#+!$,;'@()*[]")
    url_file_handle = urllib.request.urlopen(fullurl)
    print(url_local_path)
    with open(url_local_path, 'wb') as file_handle:
        file_handle.write(url_file_handle.read())

    return url_local_path
Exemple #5
0
    def __init__(self, db=None):

        logging.Handler.__init__(self)
        if db is None:
            self.db = ':memory:Temp.db'
        else:
            self.db = Path(db)
            self.db.makedirs()

        # Create table if needed:
        conn = sqlite3.connect(self.db)
        conn.execute(SQLiteHandler.initial_sql)
        conn.commit()
Exemple #6
0
 def loadUi(self, parent=None):
     if issubclass(self.__class__, QtGui.QWizard) :
         return
     try:
         path = Path(sys.modules[self.__module__].__file__)
     except:
         path = Path(apiUtils.getMainDir())
     
     if path :
         ui_file = path.dir().join('views','{0}.ui'.format(self.__class__.__name__))
         if ui_file.exists() :
             self = loadUi(ui_file, parent, self, self.customWidgets())
         else:
             print 'Unable to load ui file | {0}'.format(ui_file)
Exemple #7
0
    def loadUi(self, parent=None):
        if issubclass(self.__class__, QtGui.QWizard):
            return
        try:
            path = Path(sys.modules[self.__module__].__file__)
        except:
            path = Path(apiUtils.getMainDir())

        if path:
            ui_file = path.dir().join('views',
                                      '{0}.ui'.format(self.__class__.__name__))
            if ui_file.exists():
                self = loadUi(ui_file, parent, self, self.customWidgets())
            else:
                print('Unable to load ui file | {0}'.format(ui_file))
Exemple #8
0
    def updateWorkspace(self, mappings, root=[]):
        if guiUtils.getConfirmDialog(
                'Would you like to use your default workspace?\n{0}'.format(
                    self.p4Client())):
            workspace_name = self.p4Client
        else:
            sample = str(
                os.getenv('USERNAME') + '_' + os.getenv('COMPUTERNAME') +
                '_dev')
            workspace_success, workspace_name = guiUtils.getUserInput(
                'Please specify a name for the P4 workspace to update.\n EXAMPLE:  {0}'
                .format(os.getenv('P4CLIENT', sample)))
            if not workspace_success:
                return
            workspace_name = workspace_name.replace(" ", "_")

        client_spec = self.p4Conn.fetch_client(workspace_name)
        if 'Update' not in client_spec or 'Access' not in client_spec:  #NEW WORKSPACE
            drives = apiUtils.getDrives()
            success, choice = ChoiceWidget.getChoice(
                msg='Please specify a drive location for this P4 workspace.',
                choices=drives)
            if not success:
                return False
            client_spec['Root'] = str(Path(drives[choice] + ':\\').join(*root))

        client_spec['View'] = [x.format(workspace_name) for x in mappings]
        self.p4Conn.save_client(client_spec)
        return True
Exemple #9
0
 def getStyleSheet():
     ss_file = Path(
         settings.PKG_RESOURCE_PATH).join('darkorange.stylesheet')
     data = ''
     with open(ss_file, 'r') as file_handle:
         data = file_handle.read()
     return '%s' % data
Exemple #10
0
    def _readSettings(self):        
        settings = QtCore.QSettings(Path.getTempPath().join('ui_settings', apiUtils.getClassName(self) + '.ini'),
                                    QtCore.QSettings.IniFormat)
        settings.beginGroup(apiUtils.getClassName(self))
        
        self.readSettings(settings)

        settings.endGroup()
Exemple #11
0
 def __init__(self, func, sort='cumulative', strip_dirs=False):
     super(Profile, self).__init__(func)
     self.sort = sort
     self.strip_dirs = strip_dirs
     base_path = Path.getTempPath().join('profile')
     base_path.makedirs()
     self.profile_path = base_path.join('{0}.{1}.profile'.format(func.__module__, func.__name__))
     self.stats_path = base_path.join('{0}.{1}.log'.format(func.__module__, func.__name__))
     self.profile = cProfile.Profile()
Exemple #12
0
    def _readSettings(self):
        settings = QtCore.QSettings(
            Path.getTempPath().join('ui_settings',
                                    apiUtils.getClassName(self) + '.ini'),
            QtCore.QSettings.IniFormat)
        settings.beginGroup(apiUtils.getClassName(self))

        self.readSettings(settings)

        settings.endGroup()
Exemple #13
0
 def uploadFile(self, srcPath, destPath):
     db = self.getClient()
     srcPath = Path(srcPath)
     destPath = Path(destPath)
     destPath.makedirs()
     if srcPath.exists():
         result = db.put_file(destPath, open(srcPath, 'rb'))
         return result
     return None
Exemple #14
0
 def __init__(self, func, sort='cumulative', strip_dirs=False):
     super(Profile, self).__init__(func)
     self.sort = sort
     self.strip_dirs = strip_dirs
     base_path = Path.getTempPath().join('profile')
     base_path.makedirs()
     self.profile_path = base_path.join('{0}.{1}.profile'.format(
         func.__module__, func.__name__))
     self.stats_path = base_path.join('{0}.{1}.log'.format(
         func.__module__, func.__name__))
     self.profile = cProfile.Profile()
Exemple #15
0
def runFile( filepath, basePath=None, cmd=None, debug=False ):
    """
    Runs the filepath in a shell with proper commands given, or passes 
    the command to the shell. (CMD in windows) the current platform

    :param filepath: path to the file to execute
    :param basePath: working directory where the command should be called
    from.  If omitted, the current working directory is used.

    """
    status = False
    filepath = Path(filepath)

    # make sure the filepath we're running is a file 
    if not filepath.isfile():
        return status

    # determine the base path for the system
    if basePath is None:
        basePath = filepath.dir()

    options = { 'filepath': filepath, 'basepath': basePath }

    if cmd == None :
        if filepath.ext in ['.py','.pyw']:
            if debug:
                cmd = 'python.exe "{0}"'.format(filepath)
            else:
                cmd = 'pythonw.exe "{0}"'.format(filepath)

            status = subprocess.Popen( cmd, stdout=sys.stdout, stderr=sys.stderr, shell=debug, cwd=basePath)

    if not status :
        try:
            status = os.startfile(filepath)
        except:
            print 'runFile cannot run type (*{0})'.format(filepath.ext)

    return status
    def __init__(self, db=None):

        logging.Handler.__init__(self)
        if db is None:
            self.db = ":memory:Temp.db"
        else:
            self.db = Path(db)
            self.db.makedirs()

        # Create table if needed:
        conn = sqlite3.connect(self.db)
        conn.execute(SQLiteHandler.initial_sql)
        conn.commit()
Exemple #17
0
def runFile( filepath, basePath=None, cmd=None, debug=False ):
    """
    Runs the filepath in a shell with proper commands given, or passes 
    the command to the shell. (CMD in windows) the current platform

    :param filepath: path to the file to execute
    :param basePath: working directory where the command should be called
    from.  If omitted, the current working directory is used.

    """
    status = False
    filepath = Path(filepath)

    # make sure the filepath we're running is a file 
    if not filepath.isfile():
        return status

    # determine the base path for the system
    if basePath is None:
        basePath = filepath.dir()

    options = { 'filepath': filepath, 'basepath': basePath }

    if cmd == None :
        if filepath.ext in ['.py','.pyw']:
            if debug:
                cmd = 'python.exe "{0}"'.format(filepath)
            else:
                cmd = 'pythonw.exe "{0}"'.format(filepath)

            status = subprocess.Popen( cmd, stdout=sys.stdout, stderr=sys.stderr, shell=debug, cwd=basePath)

    if not status :
        try:
            status = os.startfile(filepath)
        except:
            print('runFile cannot run type (*{0})'.format(filepath.ext))

    return status
Exemple #18
0
    def onFinalize(self, loginMsg='Login', credentialsFile=''):
        apiUtils.synthesize(self, 'loginMsg', loginMsg)
        apiUtils.synthesize(self, 'credentialsFile', Path(credentialsFile))
        apiUtils.synthesize(self, 'submitted', False)

        self.setModal(True)

        self.ui_loginMessage.setText(self.loginMsg)
        self.ui_submit.clicked.connect(self.emitLoginSubmitted)
        self.ui_username.returnPressed.connect(self.emitLoginSubmitted)
        self.ui_password.returnPressed.connect(self.emitLoginSubmitted)
        self.ui_password.setEchoMode(QtGui.QLineEdit.Password)

        self.center()

        if self.credentialsFile:
            self._readCredentials()
Exemple #19
0
 def _tryCredentials(self, msg='P4 Login', force=False):
     #Validate Credentials
     if self.p4User is None or self.p4Password is None:
         success, user, password = LoginWidget.getCredentials(loginMsg=msg,
                                                              credentialsFile=Path.getTempPath().join('p4_login.dat'),
                                                              force=force)
         if not success:
             raise ValueError('Invalid Login Infomation!')
         self.setP4User(user)
         self.setP4Password(password)
     
     self.p4Conn.user = self.p4User
     self.p4Conn.password = self.p4Password
     
     try:
         self.p4Conn.run_login()
     except P4Exception, e:
         self.setP4User(None)
         self.setP4Password(None)
         self._tryCredentials(msg='P4 Login Invalid!', force=True)
Exemple #20
0
    def _tryCredentials(self, msg='P4 Login', force=False):
        #Validate Credentials
        if self.p4User is None or self.p4Password is None:
            success, user, password = LoginWidget.getCredentials(
                loginMsg=msg,
                credentialsFile=Path.getTempPath().join('p4_login.dat'),
                force=force)
            if not success:
                raise ValueError('Invalid Login Infomation!')
            self.setP4User(user)
            self.setP4Password(password)

        self.p4Conn.user = self.p4User
        self.p4Conn.password = self.p4Password

        try:
            self.p4Conn.run_login()
        except P4Exception as e:
            self.setP4User(None)
            self.setP4Password(None)
            self._tryCredentials(msg='P4 Login Invalid!', force=True)
        except:
            raise
Exemple #21
0
import unittest
from DTL.api import Path, Profile, loggingUtils

LOCALPATH = Path(__file__).parent

@Profile
def main():
    suite = unittest.TestLoader().discover(LOCALPATH.join('unittests'))
    unittest.TextTestRunner(verbosity=2).run(suite)

if __name__ == "__main__":
    main()
Exemple #22
0
 def _return_file(self, file_dialog):
     if file_dialog.exec_():
         returned_file = str(file_dialog.selectedFiles()[0])
         return Path(returned_file).expand()
     return Path('')
Exemple #23
0
import sys
import P4
import subprocess
import webbrowser
import difflib


from DTL.api import CheckVersion, Path
from DTL.gui import guiUtils
from DTL.perforce import P4Client
from DTL.crucible import CrucibleClient

LOCALPATH = Path.getMainDir()

def main(p4clientName, p4changeId):    
    delete = []
    add = []
    notDiffable = []
    unchanged = []
    shelved = []
    diff = []

    p4_client = P4Client(p4clientName)
    
    #Compile opened and shelved files
    files = []
    for item in [f for f in p4_client.run('describe', p4changeId)[0].get('depotFile',[])]:
        files.append(p4_client.run('fstat', item)[0])
    for item in [f for f in p4_client.run('describe', '-S', p4changeId)[0].get('depotFile',[])]:
        files.append(p4_client.run('fstat', '-Rs', '-e', p4changeId, item)[0])    
    
Exemple #24
0
 def openPath(self):
     userInputPath = Path(str(self.ui_Field.text()))
     if userInputPath:
         subprocess.call('explorer ' + userInputPath.dir().caseSensative())
Exemple #25
0
 def getWorkspaceRoot(self):
     return Path(self.p4Info['clientRoot'])
Exemple #26
0
 def getDirFromUser(self, parent=None):
     output = cmds.fileDialog2(fm=3, caption='Choose...')
     if output is None :
         return Path('')
     else :
         return Path(output[0])
Exemple #27
0
 def deserialize(self, datadict={}, filepath=''):
     apiUtils.synthesize(self, 'filepath', Path(filepath))
     self.read()
     self._set_data(datadict=datadict)
Exemple #28
0
 def getWorkspacePath(self, path):
     return Path(
         path.replace("//" + self.p4Info['clientName'],
                      self.p4Info['clientRoot']))
Exemple #29
0
 def openPath(self):
     userInputPath = Path(str(self.ui_Field.text()))
     if userInputPath :
         subprocess.call('explorer ' + userInputPath.dir().caseSensative())
Exemple #30
0
class SQLiteHandler(logging.Handler):
    """
    Logging handler for SQLite.

    Based on Vinay Sajip's DBHandler class (http://www.red-dove.com/python_logging.html)

    This version sacrifices performance for thread-safety:
    Instead of using a persistent cursor, we open/close connections for each entry.

    AFAIK this is necessary in multi-threaded applications, 
    because SQLite doesn't allow access to objects across threads.
    """

    initial_sql = """CREATE TABLE IF NOT EXISTS log(
                        Created text,
                        Name text,
                        LogLevel int,
                        LogLevelName text,    
                        Message text,
                        Args text,
                        Module text,
                        FuncName text,
                        LineNo int,
                        Exception text,
                        Process int,
                        Thread text,
                        ThreadName text
                   )"""

    insertion_sql = """INSERT INTO log(
                        Created,
                        Name,
                        LogLevel,
                        LogLevelName,
                        Message,
                        Args,
                        Module,
                        FuncName,
                        LineNo,
                        Exception,
                        Process,
                        Thread,
                        ThreadName
                   )
                   VALUES (
                        '%(dbtime)s',
                        '%(name)s',
                        %(levelno)d,
                        '%(levelname)s',
                        '%(msg)s',
                        '%(args)s',
                        '%(module)s',
                        '%(funcName)s',
                        %(lineno)d,
                        '%(exc_text)s',
                        %(process)d,
                        '%(thread)s',
                        '%(threadName)s'
                   );
                   """

    #------------------------------------------------------------
    def __init__(self, db=None):

        logging.Handler.__init__(self)
        if db is None:
            self.db = ':memory:Temp.db'
        else:
            self.db = Path(db)
            self.db.makedirs()

        # Create table if needed:
        conn = sqlite3.connect(self.db)
        conn.execute(SQLiteHandler.initial_sql)
        conn.commit()

    #------------------------------------------------------------
    def formatDBTime(self, record):
        record.dbtime = time.strftime(CODETIMEFORMAT,
                                      time.localtime(record.created))

    #------------------------------------------------------------
    def emit(self, record):

        # Use default formatting:
        self.format(record)
        # Set the database time up:
        self.formatDBTime(record)
        if record.exc_info:
            record.exc_text = logging._defaultFormatter.formatException(
                record.exc_info)
        else:
            record.exc_text = ""
        # Insert log record:
        sql = SQLiteHandler.insertion_sql % record.__dict__
        conn = sqlite3.connect(self.db)
        conn.execute(sql)
        conn.commit()
Exemple #31
0
 def setFilepath(self, filepath):
     self._filepath = Path(filepath)
Exemple #32
0
 def getSaveFileFromUser(self, parent=None, ext=[]):
     output = cmds.fileDialog2(fm=0, okc='Save', caption='Save...')
     if output is None :
         return Path('')
     else :
         return Path(output[0])
class SQLiteHandler(logging.Handler):
    """
    Logging handler for SQLite.

    Based on Vinay Sajip's DBHandler class (http://www.red-dove.com/python_logging.html)

    This version sacrifices performance for thread-safety:
    Instead of using a persistent cursor, we open/close connections for each entry.

    AFAIK this is necessary in multi-threaded applications, 
    because SQLite doesn't allow access to objects across threads.
    """

    initial_sql = """CREATE TABLE IF NOT EXISTS log(
                        Created text,
                        Name text,
                        LogLevel int,
                        LogLevelName text,    
                        Message text,
                        Args text,
                        Module text,
                        FuncName text,
                        LineNo int,
                        Exception text,
                        Process int,
                        Thread text,
                        ThreadName text
                   )"""

    insertion_sql = """INSERT INTO log(
                        Created,
                        Name,
                        LogLevel,
                        LogLevelName,
                        Message,
                        Args,
                        Module,
                        FuncName,
                        LineNo,
                        Exception,
                        Process,
                        Thread,
                        ThreadName
                   )
                   VALUES (
                        '%(dbtime)s',
                        '%(name)s',
                        %(levelno)d,
                        '%(levelname)s',
                        '%(msg)s',
                        '%(args)s',
                        '%(module)s',
                        '%(funcName)s',
                        %(lineno)d,
                        '%(exc_text)s',
                        %(process)d,
                        '%(thread)s',
                        '%(threadName)s'
                   );
                   """

    # ------------------------------------------------------------
    def __init__(self, db=None):

        logging.Handler.__init__(self)
        if db is None:
            self.db = ":memory:Temp.db"
        else:
            self.db = Path(db)
            self.db.makedirs()

        # Create table if needed:
        conn = sqlite3.connect(self.db)
        conn.execute(SQLiteHandler.initial_sql)
        conn.commit()

    # ------------------------------------------------------------
    def formatDBTime(self, record):
        record.dbtime = time.strftime(CODETIMEFORMAT, time.localtime(record.created))

    # ------------------------------------------------------------
    def emit(self, record):

        # Use default formatting:
        self.format(record)
        # Set the database time up:
        self.formatDBTime(record)
        if record.exc_info:
            record.exc_text = logging._defaultFormatter.formatException(record.exc_info)
        else:
            record.exc_text = ""
        # Insert log record:
        sql = SQLiteHandler.insertion_sql % record.__dict__
        conn = sqlite3.connect(self.db)
        conn.execute(sql)
        conn.commit()