def checkEnvFile(cls, target, otherPaths=None):
"""Doc..."""
pathSep = OsUtils.getPerOsValue(';', ':')
additions = cls._getSourcePaths(otherPaths=otherPaths)
with open(target, 'r') as f:
contents = f.read()
result = cls._PYTHON_PATH_PATTERN.search(contents)
if not result:
return False
paths = result.groupdict()['paths'].split(pathSep)
for addition in additions:
found = False
for p in paths:
p = FileUtils.cleanupPath(p, noTail=True)
if p == FileUtils.cleanupPath(addition.folderPath,
noTail=True):
found = True
break
if not found:
return False
return True
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 _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 __init__(self, localRootPath, sourceWebRootPath, forceHtml =False, forceAll =False, **kwargs):
"""Creates a new instance of S3SiteDeployer."""
self._logger = ArgsUtils.getLogger(self, kwargs)
self._localRootPath = FileUtils.cleanupPath(localRootPath, isDir=True)
self._sourceWebRootPath = FileUtils.cleanupPath(sourceWebRootPath, isDir=True)
self._forceHtml = forceHtml
self._forceAll = forceAll
self._cdnRootPath = None
try:
siteData = JSON.fromFile(FileUtils.createPath(
sourceWebRootPath, '__site__.def', isFile=True), throwError=True)
except Exception, err:
self._logger.writeError(
u'Failed to read __site__.def file. Check to make sure JSON is valid.', err)
siteData = {}
def path(self):
if not self._path:
return None
if not StringUtils.ends(self._path, '.csv'):
if not FileUtils.getFileExtension(self._path):
self._path += '.csv'
return FileUtils.cleanupPath(self._path, isFile=True)
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 initializeFromInternalPath(cls, referencePath, force =False):
""" Used to explicitly initialiize the pyglass environment when running inside the source
code respository with a standard structure where the repository root has a src and
a resources folder. """
if cls.isInitialized and not force:
return True
path = FileUtils.cleanupPath(referencePath, noTail=True)
if os.path.isfile(path):
path = FileUtils.getDirectoryOf(referencePath, noTail=True)
rootPath = None
while path:
srcPath = FileUtils.makeFolderPath(path, 'src', isDir=True)
resPath = FileUtils.makeFolderPath(path, 'resources', isDir=True)
if os.path.exists(srcPath) and os.path.exists(resPath):
rootPath = path
break
path = FileUtils.getDirectoryOf(path, noTail=True)
if not rootPath:
return False
cls._rootResourcePath = FileUtils.makeFolderPath(rootPath, 'resources')
cls._rootLocalResourcePath = FileUtils.makeFolderPath(rootPath, 'resources', 'local')
return True
def _handleLocatePath(self):
self.refreshGui()
path = QtGui.QFileDialog.getExistingDirectory(
self, caption=u'Specify Root NGinx Path', dir=self.rootPath)
if path:
path = FileUtils.cleanupPath(path)
self._pathLineEdit.setText(path)
def browseForDirectory(cls, parent, caption =None, defaultPath =None):
out = QtGui.QFileDialog.getExistingDirectory(
parent,
caption=caption if caption else u'Select a Directory',
dir=defaultPath if defaultPath else os.path.expanduser('~'))
if not out:
return out
return FileUtils.cleanupPath(out, isDir=True)
def browseForFileOpen(cls, parent, caption =None, defaultPath =None):
out = QtGui.QFileDialog.getOpenFileName(
parent,
caption=caption if caption else u'Select a File',
dir=defaultPath if defaultPath else os.path.expanduser('~'))
if not out or not out[0]:
return out
return FileUtils.cleanupPath(out[0], isFile=True)
def toFile(self, path):
path = FileUtils.cleanupPath(path, isFile=True)
try:
f = open(path, 'wb')
f.write(self._data)
f.close()
except Exception:
print('FAILED: Write ByteChunk to file')
raise
def browseForFileOpen(cls, parent, caption =None, defaultPath =None, allowMultiple =False, filterDefs =None):
QFD = QtGui.QFileDialog
f = QFD.getOpenFileNames if allowMultiple else QFD.getOpenFileName
out = f(
parent,
caption=caption if caption else 'Select a File',
dir=defaultPath if defaultPath else os.path.expanduser('~'),
filter=cls.getFileFilterString(filterDefs))
if not out or not out[0]:
return None
if not allowMultiple:
return FileUtils.cleanupPath(out[0], isFile=True)
items = []
for item in out[0]:
items.append(FileUtils.cleanupPath(item, isFile=True))
return items
def toFile(self, path):
path = FileUtils.cleanupPath(path, isFile=True)
try:
f = open(path, 'wb')
f.write(self._data)
f.close()
except Exception:
print('FAILED: Write ByteChunk to file')
raise
def browseForFileSave(cls, parent, caption =None, defaultPath =None, filterDefs =None):
out = QtGui.QFileDialog.getSaveFileName(
parent,
caption=caption if caption else 'Specify File',
dir=defaultPath if defaultPath else os.path.expanduser('~'),
options=QtGui.QFileDialog.AnyFile,
filter=cls.getFileFilterString(filterDefs))
if not out or not out[0]:
return None
return FileUtils.cleanupPath(out[0], isFile=True)
def _handleLocatePath(self):
self.refreshGui()
path = QtGui.QFileDialog.getExistingDirectory(
self,
caption=u'Specify Root NGinx Path',
dir=self.rootPath
)
if path:
path = FileUtils.cleanupPath(path)
self._pathLineEdit.setText(path)
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
def _handleBrowseFolders(self):
path = QtGui.QFileDialog.getExistingDirectory(
self,
'Select Project Folder',
self.appConfig.get(self._LAST_PROJECT_PATH, u''))
if not path:
return
path = FileUtils.cleanupPath(path, isDir=True)
self.appConfig.set(self._LAST_PROJECT_PATH, path)
self.pathLine.setText(path)
self.openBtn.setEnabled(True)
def __init__(self, rootPath =None, recursive =True, **kwargs):
"""Creates a new instance of WidgetUiCompiler."""
self._log = Logger(self)
self._verbose = ArgsUtils.get('verbose', False, kwargs)
self._recursive = recursive
self._pythonPath = os.path.normpath(sys.exec_prefix)
if rootPath and os.path.isabs(rootPath):
self._rootPath = FileUtils.cleanupPath(rootPath, isDir=True)
elif rootPath:
parts = rootPath.split(os.sep if rootPath.find(os.sep) != -1 else '/')
self._rootPath = PyGlassEnvironment.getRootResourcePath(*parts, isDir=True)
else:
self._rootPath = PyGlassEnvironment.getRootResourcePath()
def createIcon(cls, iconsPath):
""" Creates a window icon from a path, adding the standard icon sizes for multiple
operating systems. """
if not os.path.exists(iconsPath):
return None
iconsPath = FileUtils.cleanupPath(iconsPath, isDir=True)
icon = QtGui.QIcon()
sizes = [512, 256, 180, 128, 96, 72, 64, 48, 32, 24, 16]
for size in sizes:
path = FileUtils.createPath(iconsPath, str(size) + '.png', isFile=True)
if os.path.exists(path):
icon.addFile(path)
return icon
def checkEnvFile(cls, target, otherPaths =None):
"""Doc..."""
pathSep = OsUtils.getPerOsValue(';', ':')
additions = cls._getSourcePaths(otherPaths=otherPaths)
with open(target, 'r') as f:
contents = f.read()
result = cls._PYTHON_PATH_PATTERN.search(contents)
if not result:
return False
paths = result.groupdict()['paths'].split(pathSep)
for addition in additions:
found = False
for p in paths:
p = FileUtils.cleanupPath(p, noTail=True)
if p == FileUtils.cleanupPath(addition.folderPath, noTail=True):
found = True
break
if not found:
return False
return True
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
def _getIconPath(self):
path = self.iconPath
if not path:
return ''
if isinstance(path, basestring):
if os.path.isabs(path) and os.path.exists(path):
return FileUtils.cleanupPath(path)
else:
path = path.replace('\\', '/').strip('/').split('/')
path.append('icons' if OsUtils.isWindows() else 'icons.iconset')
out = PyGlassEnvironment.getRootResourcePath(*path, isDir=True)
if os.path.exists(out):
return out
return ''
def deploy(self):
"""Doc..."""
if not os.path.exists(self._localRootPath):
return False
# Find the CDN root path if it exists
self._cdnRootPath = None
for item in os.listdir(self._localRootPath):
itemPath = FileUtils.createPath(self._localRootPath, item)
if item.startswith(StaticFlowEnvironment.CDN_ROOT_PREFIX) and os.path.isdir(itemPath):
self._cdnRootPath = FileUtils.cleanupPath(itemPath)
break
# Deploy CDN files first so they are available when the non-cdn files are deployed
if self._cdnRootPath:
os.path.walk(self._cdnRootPath, self._deployWalker, {'cdn':True})
# Walk the rest of the files not on the CDN root path
os.path.walk(self._localRootPath, self._deployWalker, {'cdn':False})
return True
def __init__(self, name=None, **kwargs):
"""Initializes settings."""
self.headerless = kwargs.get('headerless', False)
self._time = self._getTime()
self._timeCode = self._time.strftime('%y-%U')
self._timestamp = self._time.strftime('%Y|%m|%d|%H|%M|%S')
self._logPath = kwargs.get('logFolder', None)
if self._logPath:
self._logPath = FileUtils.cleanupPath(self._logPath)
self._htmlEscape = kwargs.get('htmlEscape', False)
self._storageBuffer = [] if kwargs.get('useStorageBuffer', False) else None
writeCallbacks = kwargs.get('writeCallbacks', None)
if writeCallbacks:
cbs = writeCallbacks
self._writeCallbacks = cbs if isinstance(cbs, list) else [cbs]
else:
self._writeCallbacks = []
printCallbacks = kwargs.get('printCallbacks', None)
if printCallbacks:
cbs = printCallbacks
self._printCallbacks = cbs if isinstance(cbs, list) else [cbs]
else:
self._printCallbacks = []
self._locationPrefix = kwargs.get('locationPrefix', False)
self._traceLogs = kwargs.get('printOut', False)
self._buffer = []
self._hasError = False
if isinstance(name, basestring) and len(name) > 0:
self._name = name
elif hasattr(name, '__class__'):
try:
self._name = name.__class__.__name__
except Exception, err:
self._name = 'UnknownObject'
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 compileCoffeescript(cls, site, path):
csPath = FileUtils.cleanupPath(path, isFile=True)
outPath = FileUtils.changePathRoot(
csPath[:-6] + 'js', site.sourceWebRootPath, site.targetWebRootPath)
FileUtils.getDirectoryOf(outPath, createIfMissing=True)
outDir = os.path.dirname(outPath)
result = cls.compileCoffeescriptFile(csPath, outDir, minify=not site.isLocal)
if result['code']:
site.writeLogError(u'Failed to compile: "%s"' % unicode(path))
print result
return False
else:
site.writeLogSuccess(u'COMPILED', unicode(path))
lastModified = FileUtils.getUTCModifiedDatetime(csPath)
SiteProcessUtils.createHeaderFile(outPath, lastModified)
if site.isLocal:
return True
cls.copyToCdnFolder(outPath, site, lastModified)
site.writeLogSuccess(u'COMPRESSED', unicode(outPath))
return True
def setResourceRootPath(cls, path):
cls._resourceRootOverridePath = FileUtils.cleanupPath(path, isDir=True)
def rootPath(self, value):
self._pathLineEdit.setText(FileUtils.cleanupPath(value))
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
def sslCertificatePath(self):
""" The path to the folder containing the SSL security certificate, key, and authority
files """
return FileUtils.cleanupPath(self._certPath, isDir=True) if self._certPath else None
def projectPath(self):
return FileUtils.cleanupPath(self._projectPath)
from pyaid.json.JSON import JSON
from pyaid.system.SystemUtils import SystemUtils
FOLDER_NAME = 'Statistical-Results'
#---------------------------------------------------------------------------------------------------
rootPath = FileUtils.getDirectoryOf(__file__)
localAnalysisPath = FileUtils.makeFolderPath(rootPath, '..', 'resources', 'local', 'analysis')
analysisConfigPath = FileUtils.makeFilePath(localAnalysisPath, 'analysis.json')
config = JSON.fromFile(analysisConfigPath)
if 'OUTPUT_PATH' not in config:
rootTargetPath = localAnalysisPath
else:
rootTargetPath = FileUtils.cleanupPath(config['OUTPUT_PATH'], isDir=True)
targetPath = FileUtils.makeFolderPath(rootTargetPath, FOLDER_NAME)
if os.path.exists(targetPath):
SystemUtils.remove(targetPath)
outputPath = FileUtils.makeFolderPath(rootPath, 'output')
if not SystemUtils.copy(outputPath, targetPath, echo=True):
print('[FAILED]: Deployment')
sys.exit(1)
print('Deployment Complete')
def fromRootPath(cls, path):
"""Doc..."""
parts = path.rsplit(os.sep, 1)
return MayaEnvEntry(parts[-1],
FileUtils.cleanupPath(parts[0], noTail=True))
def initializeExplicitAppSettings(cls, rootResourcePath, rootLocalResourcePath):
cls._rootResourcePath = FileUtils.cleanupPath(rootResourcePath, isDir=True)
cls._rootLocalResourcePath = FileUtils.cleanupPath(rootLocalResourcePath, isDir=True)
def rootPath(self, value):
self._pathLineEdit.setText(FileUtils.cleanupPath(value))
def fromRootPath(cls, path):
"""Doc..."""
parts = path.rsplit(os.sep, 1)
return MayaEnvEntry(parts[-1], FileUtils.cleanupPath(parts[0], 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
def rootPath(self):
path = self._pathLineEdit.text()
if path:
return FileUtils.cleanupPath(path)
return u''
