def _executeBuildScript(self, scriptName): pd = self._flexData scriptsPath = FileUtils.createPath(pd.projectPath, 'compiler', 'scripts', isDir=True) if not os.path.exists(scriptsPath): return False typePath = FileUtils.createPath(scriptsPath, self._flexData.buildTypeFolderName, isDir=True) if not os.path.exists(typePath): return False platformPath = FileUtils.createPath(typePath, pd.currentPlatformID.lower(), isDir=True) if not os.path.exists(platformPath): return False targetPath = FileUtils.createPath(platformPath, scriptName, isFile=True) if not os.path.exists(targetPath): targetPath += '.py' if not os.path.exists(targetPath): return False self._log.write('Running post build script: ' + scriptName) f = open(targetPath, 'r') script = f.read() f.close() module = imp.new_module('postBuildScriptModule') setattr(module, '__file__', targetPath) setattr(module, 'logger', self._log) setattr(module, 'flexProjectData', self._flexData) exec script in module.__dict__ self._log.write('Post build script execution complete')
def _getJDKPath(cls, *args, **kwargs): if cls._JDK_PATH is None: jdkPath = None lastParts = [0, 0, 0, 0] for root in [cls._PROG_64_PATH, cls._PROG_PATH]: for p in os.listdir(FileUtils.createPath(root, 'java')): if not p.lower().startswith('jdk'): continue parts = cls._NUM_FINDER.findall(p) skip = False index = 0 while index < len(lastParts) and index < len(parts): if parts[index] < lastParts[index]: skip = True break index += 1 if not skip: lastParts = parts jdkPath = FileUtils.createPath(cls._PROG_64_PATH, 'java', p) cls._JDK_PATH = jdkPath if cls._JDK_PATH is None: raise Exception, 'Unable to locate a Java Development Kit installation.' return FileUtils.createPath(cls._JDK_PATH, *args, **kwargs)
def locateMayaEnvFiles(cls): """ Finds the location of all Maya.env files located in the default location on the host and return them as a list. If no such env files exist, the method returns an empty list. """ home = FileUtils.cleanupPath(OsUtils.getHomePath(), isDir=True) if not os.path.exists(home): return [] if OsUtils.isWindows(): root = FileUtils.createPath(OsUtils.getDocumentsPath(), 'maya', isDir=True) if not os.path.exists(root): return [] elif OsUtils.isMac(): root = FileUtils.createPath(home, 'Library', 'Preferences', 'Autodesk', 'maya', isDir=True) if not os.path.exists(root): return [] else: return [] out = [] FileUtils.walkPath(root, cls._handleFindEnvFiles, out) return out
def appleProvisioningProfile(self): if self._currentPlatformID != self.IOS_PLATFORM: return None certPaths = [ FileUtils.createPath( self.platformProjectPath, 'cert', self.buildTypeFolderName, isDir=True), FileUtils.createPath(self.platformProjectPath, 'cert', isDir=True) ] if self.iosAdHoc: certPaths.insert(0, FileUtils.createPath( self.platformProjectPath, 'cert', 'adhoc', isDir=True)) for certPath in certPaths: if not os.path.exists(certPath): continue filename = self.getSetting('PROVISIONING_PROFILE', None) if filename is None: for path in FileUtils.getFilesOnPath(certPath): if path.endswith('.mobileprovision'): return path continue filename = filename.replace('\\', '/').strip('/').split('/') path = FileUtils.createPath(certPath, filename, isFile=True) if not os.path.exists(path) and os.path.exists(path + '.mobileprovision'): path += '.mobileprovision' if os.path.exists(path): return path return None
def _createMacDmg(self, binPath): print 'CREATING Mac DMG' target = FileUtils.createPath(binPath, self.application.appID + '.dmg', isFile=True) tempTarget = FileUtils.createPath(binPath, 'pack.tmp.dmg', isFile=True) distPath = FileUtils.createPath(binPath, 'dist', isDir=True, noTail=True) if os.path.exists(tempTarget): SystemUtils.remove(tempTarget) cmd = ['hdiutil', 'create', '-size', '500m', '"%s"' % tempTarget, '-ov', '-volname', '"%s"' % self.appDisplayName, '-fs', 'HFS+', '-srcfolder', '"%s"' % distPath] result = SystemUtils.executeCommand(cmd, wait=True) if result['code']: print 'Failed Command Execution:' print result return False cmd = ['hdiutil', 'convert', "%s" % tempTarget, '-format', 'UDZO', '-imagekey', 'zlib-level=9', '-o', "%s" % target] if os.path.exists(target): SystemUtils.remove(target) result = SystemUtils.executeCommand(cmd) if result['code']: print 'Failed Command Execution:' print result return False SystemUtils.remove(tempTarget) return True
def initializeEnvironment(cls, path): """ CREATE MISSING FILES AND FOLDERS Due to the limited file creation privileges while running NGinx as a normal user, certain files and folders must exist prior to starting the server. """ for folderParts in cls._NGINX_FOLDERS: p = FileUtils.createPath(path, *folderParts, isDir=True) if not os.path.exists(p): os.makedirs(p) for fileParts in cls._NGINX_FILES: p = FileUtils.createPath(path, *fileParts, isFile=True) if not os.path.exists(p): f = open(p, 'w+') f.close() #------------------------------------------------------------------------------------------- # COPY CONF FILES # NGinx requires a number of conf files to be present and comes with a default set of # files, which must be cloned to the target location if they do not already exist. nginxExeConfFolder = FileUtils.createPath(NGinxSetupOps.getExePath(), 'conf', isDir=True) for item in os.listdir(nginxExeConfFolder): itemPath = FileUtils.createPath(nginxExeConfFolder, item) if not os.path.isfile(itemPath): continue targetPath = FileUtils.createPath(path, 'conf', item, isFile=True) if os.path.exists(targetPath): continue shutil.copy(itemPath, targetPath)
def certificate(self): """Returns the absolute path to the certificate file needed for packaging.""" certPaths = [ FileUtils.createPath( self.platformProjectPath, 'cert', self.buildTypeFolderName, isDir=True), FileUtils.createPath(self.platformProjectPath, 'cert', isDir=True) ] for certPath in certPaths: if not os.path.exists(certPath): continue certFileName = self.getSetting('CERTIFICATE') if certFileName is None: for path in FileUtils.getFilesOnPath(certPath): if path.endswith('.p12'): return path continue certFileName = certFileName.replace('\\', '/').strip('/').split('/') certPath = FileUtils.createPath(certPath, certFileName, isFile=True) if not os.path.exists(certPath) and os.path.exists(certPath + '.p12'): certPath += '.p12' if os.path.exists(certPath): return certPath return None
def __init__(self): """Creates a new instance of PyGlassApplication.""" QtCore.QObject.__init__(self) self._qApplication = None self._window = None self._splashScreen = None # Sets a temporary standard out and error for deployed applications in a write allowed # location to prevent failed write results. if PyGlassEnvironment.isDeployed: if appdirs: userDir = appdirs.user_data_dir(self.appID, self.appGroupID) else: userDir = FileUtils.createPath( os.path.expanduser('~'), '.pyglass', self.appGroupID, self.appID, isDir=True) path = FileUtils.createPath( userDir, self.appID + '_out.log', isFile=True) folder = FileUtils.getDirectoryOf(path, createIfMissing=True) sys.stdout = open(path, 'w+') FileUtils.createPath( appdirs.user_data_dir(self.appID, self.appGroupID), self.appID + '_error.log', isFile=True) folder = FileUtils.getDirectoryOf(path, createIfMissing=True) sys.stderr = open(path, 'w+') PyGlassEnvironment.initializeAppSettings(self)
def __init__(self, containerPath, isRemoteDeploy =False, sourceRootFolder ='src', **kwargs): """Creates a new instance of Site.""" super(Site, self).__init__() self.errorCount = 0 self.warningCount = 0 self._staticPaths = [] self._logger = ArgsUtils.getLogger(self, kwargs) self._sourceRootFolderName = sourceRootFolder # NGinx root path in which all files reside self._containerPath = FileUtils.cleanupPath(containerPath, isDir=True) # Location of the source files used to create the website self._sourceWebRootPath = FileUtils.createPath(containerPath, sourceRootFolder, isDir=True) # Locations where files should be deployed. If the target root path is None, which is the # default value, the local web root path is used in its place. if isRemoteDeploy: self._targetWebRootPath = FileUtils.cleanupPath( tempfile.mkdtemp(prefix='staticFlow_'), isDir=True) else: self._targetWebRootPath = None self._localWebRootPath = FileUtils.createPath( containerPath, ArgsUtils.get('localRootFolder', 'root', kwargs), isDir=True) path = FileUtils.createPath(self.sourceWebRootPath, '__site__.def', isFile=True) try: self._data.data = JSON.fromFile(path, throwError=True) except Exception, err: self.writeLogError(u'Unable to load site definition file: "%s"' % path, error=err) pass
def initializeEnvironment(cls, path): """ CREATE MISSING FILES AND FOLDERS Due to the limited file creation privileges while running NGinx as a normal user, certain files and folders must exist prior to starting the server. """ for folderParts in cls._NGINX_FOLDERS: p = FileUtils.createPath(path, *folderParts, isDir=True) if not os.path.exists(p): os.makedirs(p) for fileParts in cls._NGINX_FILES: p = FileUtils.createPath(path, *fileParts, isFile=True) if not os.path.exists(p): f = open(p, 'w+') f.close() #------------------------------------------------------------------------------------------- # COPY CONF FILES # NGinx requires a number of conf files to be present and comes with a default set of # files, which must be cloned to the target location if they do not already exist. nginxExeConfFolder = FileUtils.createPath(NGinxSetupOps.getExePath(), 'conf', isDir=True) for item in os.listdir(nginxExeConfFolder): itemPath = FileUtils.createPath(nginxExeConfFolder, item) if not os.path.isfile(itemPath): continue targetPath = FileUtils.createPath(path, 'conf', item, isFile=True) if os.path.exists(targetPath): continue shutil.copy(itemPath, targetPath)
def deployDebugNativeExtensions(cls, cmd, settings): from CompilerDeck.adobe.flex.FlexProjectData import FlexProjectData sets = settings if not sets.aneIncludes: return None debugPath = FileUtils.createPath( sets.projectPath, 'NativeExtensions', '__debug__', isDir=True, noTail=True) if os.path.exists(debugPath): SystemUtils.remove(debugPath) os.makedirs(debugPath) extensionIDs = [] for ane in sets.aneIncludes: anePath = FileUtils.createPath(sets.projectPath, 'NativeExtensions', ane, isDir=True) aneSets = FlexProjectData(anePath) extensionIDs.append(aneSets.getSetting('ID')) aneFilename = aneSets.getSetting('FILENAME') aneFile = FileUtils.createPath(anePath, aneFilename + '.ane', isFile=True) z = zipfile.ZipFile(aneFile) z.extractall(FileUtils.createPath(debugPath, aneFilename + '.ane', isDir=True, noTail=True)) AirUtils.updateAppExtensions(sets.appDescriptorPath, extensionIDs) cmd.extend(['-extdir', '"%s"' % debugPath]) return debugPath
def platformProjectPath(self): """The root project path for the currently active platform.""" pid = self._currentPlatformID if pid == self.ANDROID_PLATFORM: return FileUtils.createPath(self.projectPath, 'android', isDir=True) elif pid == self.IOS_PLATFORM: return FileUtils.createPath(self.projectPath, 'ios', isDir=True) return self.projectPath
def _compileUiFile(self, path, filename): """Doc...""" source = FileUtils.createPath(path, filename, isFile=True) if self._verbose: self._log.write('COMPILING: ' + source) if PyGlassEnvironment.isWindows: uicCommand = FileUtils.createPath(self._pythonPath, 'Scripts', 'pyside-uic.exe') else: uicCommand = 'pyside-uic' cmd = '%s %s' % (uicCommand, source) pipe = subprocess.Popen( cmd, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, error = pipe.communicate() if pipe.returncode or error: self._log.write('ERROR: Failed to compile %s widget: %s' % (str(source), str(error))) return False res = WidgetUiCompiler._CLASS_NAME_RE.search(out) if not res: self._log.write('ERROR: Failed to find widget class name for ' + str(source)) return False out = WidgetUiCompiler._CLASS_NAME_RE.sub('PySideUiFileSetup', out, 1) res = WidgetUiCompiler._SETUP_UI_RE.search(out) if not res: self._log.write('ERROR: Failed to find widget setupUi method for ' + str(source)) return False targetName = res.groupdict().get('parentName') out = WidgetUiCompiler._SETUP_UI_RE.sub('\g<parentName>', out, 1) res = WidgetUiCompiler._RETRANSLATE_RE.search(out) if not res: self._log.write('ERROR: Failed to find widget retranslateUi method for ' + str(source)) return False out = WidgetUiCompiler._RETRANSLATE_RE.sub('\g<parentName>', out, 1) if isinstance(out, unicode): out = out.encode('utf8', 'ignore') out = WidgetUiCompiler._SELF_RE.sub(targetName + '.', out) dest = FileUtils.createPath(path, filename[:-3] + '.py', isFile=True) if os.path.exists(dest): os.remove(dest) f = open(dest, 'w+') f.write(out) f.close() py_compile.compile(dest) return True
def _createIcon(self, binPath): iconPath = self._getIconPath() if not iconPath: return iconPath if os.path.isfile(iconPath): return iconPath #------------------------------------------------------------------------------------------- # MAC ICON CREATION # On OSX use Apple's iconutil (XCode developer tools must be installed) to create an # icns file from the icons.iconset folder at the specified location. if OsUtils.isMac(): targetPath = FileUtils.createPath(binPath, self.appDisplayName + '.icns', isFile=True) result = SystemUtils.executeCommand([ 'iconutil', '-c', 'icns', '-o', '"' + targetPath + '"', '"' + iconPath + '"']) if result['code']: return '' return targetPath #------------------------------------------------------------------------------------------- # WINDOWS ICON CREATION # On Windows use convert (ImageMagick must be installed and on the PATH) to create an # ico file from the icons folder of png files. result = SystemUtils.executeCommand('where convert') if result['code']: return '' items = result['out'].replace('\r', '').strip().split('\n') convertCommand = None for item in items: if item.find('System32') == -1: convertCommand = item break if not convertCommand: return '' images = os.listdir(iconPath) cmd = ['"' + convertCommand + '"'] for image in images: if not StringUtils.ends(image, ('.png', '.jpg')): continue imagePath = FileUtils.createPath(iconPath, image, isFile=True) cmd.append('"' + imagePath + '"') if len(cmd) < 2: return '' targetPath = FileUtils.createPath(binPath, self.appDisplayName + '.ico', isFile=True) cmd.append('"' + targetPath + '"') result = SystemUtils.executeCommand(cmd) if result['code'] or not os.path.exists(targetPath): print 'FAILED:' print result['command'] print result['error'] return '' return targetPath
def path(self): if self._common: return FileUtils.createPath( self._gui.appResourcePath, ApplicationConfig._APP_COMMON_CONFIG_FILENAME) return FileUtils.createPath( self._gui.localAppResourcePath, ApplicationConfig._APP_CONFIG_FILENAME)
def faviconUrl(self): path = FileUtils.createPath(self.sourceWebRootPath, 'favicon.png', isFile=True) if os.path.exists(path): return self.getSiteUrl('/favicon.png') path = FileUtils.createPath(self.sourceWebRootPath, 'favicon.ico', isFile=True) if os.path.exists(path): return self.getSiteUrl('/favicon.ico') return None
def run(self): """Doc...""" # Create the bin directory where the output will be stored if it does not already exist binPath = self.getBinPath(isDir=True) if not os.path.exists(binPath): os.makedirs(binPath) # Remove any folders created by previous build attempts for d in self._CLEANUP_FOLDERS: path = os.path.join(binPath, d) if os.path.exists(path): shutil.rmtree(path) os.chdir(binPath) ResourceCollector(self, verbose=True).run() cmd = [ FileUtils.makeFilePath(sys.prefix, 'bin', 'python'), '"%s"' % self._createSetupFile(binPath), OsUtils.getPerOsValue('py2exe', 'py2app'), '>', '"%s"' % self.getBinPath('setup.log', isFile=True)] print('[COMPILING]: Executing %s' % OsUtils.getPerOsValue('py2exe', 'py2app')) print('[COMMAND]: %s' % ' '.join(cmd)) result = SystemUtils.executeCommand(cmd, remote=False, wait=True) if result['code']: print('COMPILATION ERROR:') print(result['out']) print(result['error']) return False if self.appFilename and OsUtils.isWindows(): name = self.applicationClass.__name__ source = FileUtils.createPath(binPath, 'dist', name + '.exe', isFile=True) dest = FileUtils.createPath(binPath, 'dist', self.appFilename + '.exe', isFile=True) os.rename(source, dest) if OsUtils.isWindows() and not self._createWindowsInstaller(binPath): print('Installer Creation Failed') return False elif OsUtils.isMac() and not self._createMacDmg(binPath): print('DMG Creation Failed') return False # Remove the resources path once compilation is complete resourcePath = FileUtils.createPath(binPath, 'resources', isDir=True) SystemUtils.remove(resourcePath) buildPath = FileUtils.createPath(binPath, 'build', isDir=True) SystemUtils.remove(buildPath) FileUtils.openFolderInSystemDisplay(binPath) return True
def platformDistributionPath(self): ptype = self.buildTypeFolderName if self.isNative: platform = 'win' if OsUtils.isWindows() else 'mac' return FileUtils.createPath( self.platformProjectPath, 'dist', 'native', platform, ptype, isDir=True) return FileUtils.createPath(self.platformProjectPath, 'dist', ptype, isDir=True)
def _cleanupInFolder(self, arg, dirname, names): for name in names: if StringUtils.ends(name, self._compiler.ignoreExtensions): os.remove(FileUtils.createPath(dirname, name, isFile=True)) # Deletes python (.py) files associated with ui files so only .pyc files remain. if name.endswith('.ui'): pyName = name.rsplit('.', 1)[0] + '.py' pyNamePath = FileUtils.createPath(dirname, pyName, isFile=True) if os.path.exists(pyNamePath): os.remove(pyNamePath)
def _htmlDefinitionWalker(self, args, path, names): # If a folder definition is found, use it to populate the directory with any missing # definition files before proceeding if '__folder__.def' in names: self._processFolderDefinitions( FileUtils.createPath(path, '__folder__.def', isFile=True)) names = os.listdir(path) # For each definition file in the directory create page data for processing for name in names: if name.endswith('.def') and not name.startswith('__'): self._pages.create(FileUtils.createPath(path, name, isFile=True))
def __init__(self, parent, test =True, install =True, check =False, verbose =True, **kwargs): """Creates a new instance of MayaIniRemoteThread.""" super(MayaIniRemoteThread, self).__init__(parent, **kwargs) self._test = test self._verbose = verbose self._install = install self._check = check self._output = {} self._cadenceEntry = MayaEnvEntry.fromRootPath(FileUtils.createPath( FileUtils.getDirectoryOf(cadence.__file__), noTail=True)) self._elixirEntry = MayaEnvEntry.fromRootPath(FileUtils.createPath( FileUtils.getDirectoryOf(elixir.__file__), noTail=True))
def _createLoaderJs(self): """Doc...""" result = SiteProcessUtils.compileCoffeescriptFile( FileUtils.createPath( StaticFlowEnvironment.rootResourcePath, '..', 'js', 'loader.coffee', isFile=True), FileUtils.createPath( StaticFlowEnvironment.rootResourcePath, 'web', 'js', isDir=True) ) if result['code']: print 'ERROR: Failed to compile loader.coffee' print result return False print u'COMPILED: loader.js' return True
def run(self): """Doc...""" # Create the bin directory where the output will be stored if it does not alread exist binPath = self.getBinPath(isDir=True) if not os.path.exists(binPath): os.makedirs(binPath) # Remove any folders created by previous build attempts for d in self._CLEANUP_FOLDERS: path = os.path.join(binPath, d) if os.path.exists(path): shutil.rmtree(path) os.chdir(binPath) ResourceCollector(self, verbose=True).run() cmd = 'python %s %s > %s' % ( self._createSetupFile(binPath), 'py2exe' if OsUtils.isWindows() else 'py2app', self.getBinPath('setup.log', isFile=True) ) result = SystemUtils.executeCommand(cmd, remote=False, wait=True) if result['code']: print 'COMPILATION ERROR:' print result['error'] return False if self.appFilename and OsUtils.isWindows(): name = self.applicationClass.__name__ source = FileUtils.createPath(binPath, 'dist', name + '.exe', isFile=True) dest = FileUtils.createPath(binPath, 'dist', self.appFilename + '.exe', isFile=True) os.rename(source, dest) if OsUtils.isWindows() and not self._createWindowsInstaller(binPath): print 'Installer Creation Failed' return False elif OsUtils.isMac() and not self._createMacDmg(binPath): print 'DMG Creation Failed' return False # Remove the resources path once compilation is complete resourcePath = FileUtils.createPath(binPath, 'resources', isDir=True) SystemUtils.remove(resourcePath) buildPath = FileUtils.createPath(binPath, 'build', isDir=True) SystemUtils.remove(buildPath) return True
def getResourcePath(self, *args, **kwargs): """Doc...""" inApp = kwargs.get('inApp', False) if inApp: return self.getAppResourcePath('widget', self._resourceFolderParts, *args, **kwargs) return FileUtils.createPath( self.mainWindow.rootResourcePath, 'widget', self._resourceFolderParts, *args, **kwargs )
def addAIRNativeExtensionArguments(cls, cmd, settings): from CompilerDeck.adobe.flex.FlexProjectData import FlexProjectData sets = settings if not sets.aneIncludes: return extensionIDs = [] for ane in sets.aneIncludes: anePath = FileUtils.createPath(sets.projectPath, 'NativeExtensions', ane, isDir=True) aneSets = FlexProjectData(anePath) cmd.extend( ['-extdir', '"%s"' % FileUtils.createPath(aneSets.projectPath, isDir=True, noTail=True)]) extensionIDs.append(aneSets.getSetting('ID')) AirUtils.updateAppExtensions(sets.appDescriptorPath, extensionIDs)
def _copyResourceFolder(self, sourcePath, parts): targetPath = FileUtils.createPath(self._targetPath, *parts, isDir=True) WidgetUiCompiler(sourcePath).run() if self._verbose: self._log.write('COPYING: %s -> %s' % (sourcePath, targetPath)) return FileUtils.mergeCopy(sourcePath, targetPath)
def getJavaAntPath(self, *args, **kwargs): """Doc...""" res = self.appConfig.get(self._JAVA_ANT_PATH) if not res: return '' return FileUtils.createPath(res, *args, **kwargs)
def getFlexSDKPath(self, *args, **kwargs): """Doc...""" res = self.appConfig.get(self._FLEX_SDK_PATH) if not res: return '' return FileUtils.createPath(res, *args, **kwargs)
def getRootAIRPath(self, *args, **kwargs): """Doc...""" res = self.appConfig.get(self._AIR_ROOT_PATH) if not res: return '' return FileUtils.createPath(res, *args, **kwargs)
def compileCoffeescriptFile(cls, source, destFolder, minify =True): iniDirectory = os.curdir os.chdir(os.path.dirname(source)) cmd = cls.modifyNodeCommand([ StaticFlowEnvironment.getNodeCommandAbsPath('coffee'), '--output', '"%s"' % FileUtils.stripTail(destFolder), '--compile', '"%s"' % source ]) result = SystemUtils.executeCommand(cmd) if not minify or result['code']: os.chdir(iniDirectory) return result name = os.path.splitext(os.path.basename(source))[0] + '.js' dest = FileUtils.createPath(destFolder, name, isFile=True) tempOutPath = dest + '.tmp' shutil.move(dest, tempOutPath) cmd = cls.modifyNodeCommand([ StaticFlowEnvironment.getNodeCommandAbsPath('uglifyjs'), '"%s"' % tempOutPath, '>', '"%s"' % dest ]) result = SystemUtils.executeCommand(cmd) os.remove(tempOutPath) os.chdir(iniDirectory) return result
def _compileWalker(self, args, path, names): for name in names: namePath = FileUtils.createPath(path, name, isFile=True) if name.endswith('.coffee'): SiteProcessUtils.compileCoffeescript(self, namePath) elif name.endswith('.css'): SiteProcessUtils.compileCss(self, namePath)
def _copyWalker(self, walkData): staticFolder = False for folder in self._staticPaths: path = FileUtils.cleanupPath(walkData.folder, isDir=True) folder = FileUtils.cleanupPath(folder, isDir=True) if path == folder or FileUtils.isInFolder(path, folder): staticFolder = True break copiedNames = [] for item in walkData.names: if not staticFolder and not StringUtils.ends(item, self._FILE_COPY_TYPES): continue sourcePath = FileUtils.createPath(walkData.folder, item) if os.path.isdir(sourcePath): continue destPath = FileUtils.changePathRoot( sourcePath, self.sourceWebRootPath, self.targetWebRootPath) try: FileUtils.getDirectoryOf(destPath, createIfMissing=True) shutil.copy(sourcePath, destPath) lastModified = FileUtils.getUTCModifiedDatetime(sourcePath) SiteProcessUtils.createHeaderFile(destPath, lastModified) SiteProcessUtils.copyToCdnFolder(destPath, self, lastModified) copiedNames.append(item) except Exception, err: self.writeLogError(u'Unable to copy file', error=err, extras={ 'SOURCE':sourcePath, 'TARGET':destPath }) return
def _getSourcePaths(cls, otherPaths=None): nimbleEntry = MayaEnvEntry.fromRootPath( FileUtils.createPath(FileUtils.getDirectoryOf(nimble.__file__), noTail=True)) pyaidEntry = MayaEnvEntry.fromRootPath( FileUtils.createPath(FileUtils.getDirectoryOf(pyaid.__file__), noTail=True)) pyglassEntry = MayaEnvEntry.fromRootPath( FileUtils.createPath(FileUtils.getDirectoryOf(pyglass.__file__), noTail=True)) additions = [nimbleEntry, pyaidEntry, pyglassEntry] if not otherPaths: return additions for p in otherPaths: additions.append(p if isinstance(p, MayaEnvEntry) else MayaEnvEntry .fromRootPath(p)) return additions
def loggingPath(self, value): self._logPath = FileUtils.cleanupPath(value) logFolder = self.getLogFolder() if logFolder: name = self._name extension = self.logFileExtension if self.timestampFileSuffix: name += '_' + self._timeCode self._logFile = FileUtils.createPath(logFolder, name + '.' + extension) if self.removeIfExists: self.resetLogFile() else: self._logFile = None
cmds.move(offset, offset, offset, name) cmds.rotate(50, 20, 10, name) cmds.scale(2, 2, 2, name) response = nimble.createRemoteResponse(globals()) response.put('name', name) response.put('offset', offset) """ #--------------------------------------------------------------------------------------------------- print('RUNNING SCRIPT:') conn = nimble.getConnection() result = conn.runPythonScript(script, offset=20) print('\tRESULT:', result, type(result)) print('\tPAYLOAD:', result.payload) #--------------------------------------------------------------------------------------------------- print('RUNNING FILE:') result = conn.runPythonScriptFile(FileUtils.createPath(os.path.abspath( os.path.dirname(__file__)), 'pythonTestScript.py', isFile=True), offset=5) print('\tRESULT:', result, type(result)) print('\tPAYLOAD:', result.payload) print('Operation Complete')
def _handleFindEnvFiles(cls, walkData): for name in walkData.names: if name == 'Maya.env': walkData.data.append( FileUtils.createPath(walkData.folder, name))
# helloPythonImport.py # (C)2014 # Scott Ernst """ This example shows how to use the advanced import scripting in Nimble. """ from __future__ import print_function, absolute_import, unicode_literals, division import sys from pyaid.file.FileUtils import FileUtils import nimble # Add the src path for this example to the python system path for access to the scripts scriptPath = FileUtils.createPath(FileUtils.getDirectoryOf(__file__), 'src', isDir=True) sys.path.append(scriptPath) from helloPythonImportExample.scripts import CreateSpheres # Create a Nimble connection object. This object will be used to send and receive across the # nimble communication bridge between this script and the Nimble server running in Maya conn = nimble.getConnection() # Add the script src path to the Maya Python environment as well so that it can import and run # the scripts directly result = conn.addToMayaPythonPath(scriptPath) if not result.success: print( 'Unable to modify Maya Python path. Are you sure Maya is running a Nimble server?'
# Check for PySide system dynamic libraries paths = [] for p in os.listdir(u'/usr/lib'): if p.endswith(u'.dylib') and p.startswith(u'libpyside-'): paths.append(p) printResult(u'PySide (Dynamic Libraries)', u'PASSED' if paths else u'FAILED') for p in paths: print u'\t', p result = SystemUtils.executeCommand('find /usr -name "libpyside-*.dylib"') print result['out'] # Check for PySide site package shared libraries foundLocation = None for p in sys.path: p = FileUtils.createPath(p, u'PySide', isDir=True) if not os.path.exists(p): continue if os.path.exists(FileUtils.createPath(p, u'QtCore.so', isFile=True)): foundLocation = p break printResult(u'PySide (Package Libraries)', u'PASSED' if foundLocation else u'FAILED') if foundLocation: print u'\t', foundLocation # Check for PySide try: from PySide import QtCore printResult(u'PySide', u'PASSED')
def rootPath(self): return FileUtils.createPath(self.folderPath, self.rootName, noTail=True)
def modifyEnvFile(cls, target, install=True, test=False, otherPaths=None): """Doc...""" pathSep = OsUtils.getPerOsValue(';', ':') removals = [] entries = cls._getSourcePaths(otherPaths=otherPaths) additions = entries + [] with open(target, 'r') as f: contents = f.read().strip() result = cls._PYTHON_PATH_PATTERN.search(contents) if not result: if install and not test: with open(target, 'w') as f: f.write((contents + '\n' if contents else '') + 'PYTHONPATH=' + cls._joinPathEntries(additions)) return cls.MAYA_ENV_MODIFIED_RESULT_NT( additions if install else [], removals) paths = result.groupdict()['paths'].strip() paths = paths.split(pathSep) if paths else [] if not paths and not install: return cls.MAYA_ENV_MODIFIED_RESULT_NT([], []) index = 0 while index < len(paths): # Stop if no more additions remain if not additions: break p = FileUtils.cleanupPath(paths[index], noTail=True) # If path already exists don't add it again pathMatch = cls._hasPath(p, additions) if pathMatch: additions.remove(pathMatch) # If uninstalling add to removals if not install: removals.append(pathMatch) paths.remove(p) else: index += 1 continue elif not install: index += 1 continue for entry in entries: testPath = FileUtils.createPath(p, entry.rootName, noTail=True) if os.path.exists(testPath): paths.remove(p) index += 1 for entry in additions: paths.append(entry.folderPath) insertion = ('PYTHONPATH=' + pathSep.join(paths) + '\n') if paths else '' contents = contents[:result.start()] + insertion + contents[result.end( ):] result = cls.MAYA_ENV_MODIFIED_RESULT_NT(additions if install else [], removals) if test: return result with open(target, 'w') as f: f.write(contents) return result