def __init__(self, parent =None, **kwargs):
"""Creates a new instance of PySideGui."""
flags = ArgsUtils.extract('flags', None, kwargs)
if flags is None:
# By default the close button is hidden (only title shows)
flags = QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowTitleHint
title = ArgsUtils.extract('title', 'Dialog', kwargs)
modal = ArgsUtils.extract('modal', True, kwargs)
widgetClass = ArgsUtils.extract('widget', None, kwargs)
self._callback = ArgsUtils.extract('callback', None, kwargs)
self._canceled = True
QtGui.QDialog.__init__(self, parent, flags)
self.setStyleSheet(self.owner.styleSheetPath)
if widgetClass is None:
self._widget = None
else:
layout = self._getLayout(self)
self._widget = widgetClass(parent=self, **kwargs)
layout.addWidget(self._widget)
self.setModal(modal)
self.setWindowTitle(title)
def __init__(self, parent, path, session=None, **kwargs):
"""Creates a new instance of TrackImporterRemoteThread."""
self._pretty = ArgsUtils.extract("pretty", False, kwargs)
self._gzipped = ArgsUtils.extract("compressed", True, kwargs)
self._difference = ArgsUtils.extract("difference", True, kwargs)
RemoteExecutionThread.__init__(self, parent, **kwargs)
self._path = path
self._session = session
def __init__(self, source, **kwargs):
self.footerDom = u''
self.page = ArgsUtils.get('page', None, kwargs)
self.site = ArgsUtils.get('site', None, kwargs)
self.filePath = ArgsUtils.get('path', None, kwargs)
self.filename = ArgsUtils.get(
'filename',
os.path.basename(self.filePath) if self.filePath else None,
kwargs)
debugData = ArgsUtils.extract('debugData', None, kwargs)
blocks = {
'root':[
MarkupTextBlockUtils.createMarkupCommentDef(BlockDefinition.BLOCKED),
MarkupTextBlockUtils.createMarkupOpenDef('quote'),
MarkupTextBlockUtils.createMarkupCloseDef(BlockDefinition.BLOCKED) ],
'quote':[
BlockDefinition.createQuoteDef(BlockDefinition.BLOCKED),
BlockDefinition.createLiteralDef(BlockDefinition.BLOCKED) ]}
self._renderErrors = []
self._tagIndex = -1
super(MarkupProcessor, self).__init__(
source,
ArgsUtils.extract('debug', False, kwargs),
blocks,
debugData,
stripSource=False,
**kwargs)
self.logger.trace = True
self._result = None
self._anchors = []
self._tags = []
self._id = StringUtils.getRandomString(8)
self._css = []
self._js = []
self._radioArrays = dict()
self._patterns = dict()
self._groups = dict()
self._metadata = ArgsUtils.getAsDict('metadata', kwargs)
self._libraryIDs = []
self._autoTitle = u''
self._autoDescription = u''
self._allowModelCaching = False
self.privateView = False
def __init__(self, parent, **kwargs):
RemoteExecutionThread.__init__(self, parent, explicitComplete=True, **kwargs)
self._pausePackageSteps = ArgsUtils.extract('pausePackageSteps', False, kwargs)
self._uploadAfterPackage = ArgsUtils.extract('uploadAfterPackage', False, kwargs)
self._flexData = FlexProjectData(**kwargs)
self._queue = []
self._isProcessingQueue = False
self._isAbortingQueue = False
self._bucket = None
self._output = dict()
if self._uploadAfterPackage:
self._output['urls'] = dict()
self._bucket = self._flexData.createBucket()
def __init__(self, parent, url, args =None, **kwargs):
"""Creates a new instance of Request."""
self._localData = ArgsUtils.extract('localData', None, kwargs)
self._dead = ArgsUtils.extract('dead', False, kwargs)
QObject.__init__(self, parent, **kwargs)
self._url = url
self._owner = parent
self._log = parent.log if parent else Logger(self)
self._callback = None
self._args = args
self._request = None
self._result = None
self._sent = False
self._async = False
def runPythonExec(script, kwargs =None):
from nimble.NimbleEnvironment import NimbleEnvironment
from nimble.data.NimbleResponseData import NimbleResponseData
from nimble.data.enum.DataKindEnum import DataKindEnum
try:
nimble.cmds.undoInfo(openChunk=True)
except Exception as err:
return False
try:
# Create a new, temporary module in which to run the script
module = imp.new_module('runExecTempModule')
# Initialize the script with script inputs
setattr(module, NimbleEnvironment.REMOTE_KWARGS_KEY, kwargs if kwargs is not None else dict())
setattr(module, NimbleEnvironment.REMOTE_RESULT_KEY, dict())
# Executes the script in the new module
exec_(script, module.__dict__)
# Find a NimbleScriptBase derived class definition and if it exists, run it to populate the
# results
for name,value in Reflection.getReflectionDict(module).iteritems():
if not inspect.isclass(value):
continue
if NimbleScriptBase in value.__bases__:
getattr(module, name)().run()
break
# Retrieve the results object that contains all results set by the execution of the script
result = getattr(module, NimbleEnvironment.REMOTE_RESULT_KEY)
except Exception as err:
logger = Logger('runPythonExec', printOut=True)
logger.writeError('ERROR: Failed Remote Script Execution', err)
result = NimbleResponseData(
kind=DataKindEnum.PYTHON_SCRIPT,
response=NimbleResponseData.FAILED_RESPONSE,
error=str(err) )
# If a result dictionary contains an error key format the response as a failure
try:
errorMessage = ArgsUtils.extract(
NimbleEnvironment.REMOTE_RESULT_ERROR_KEY, None, result)
if errorMessage:
return NimbleResponseData(
kind=DataKindEnum.PYTHON_SCRIPT,
response=NimbleResponseData.FAILED_RESPONSE,
error=errorMessage,
payload=result)
except Exception as err:
pass
try:
nimble.cmds.undoInfo(closeChunk=True)
except Exception as err:
return False
return result
def __init__(self, *args, **kwargs):
"""Creates a new instance of ListDataOrganizer."""
root = ArgsUtils.extract('root', None, kwargs, args, 0)
if isinstance(root, basestring):
root = [root]
super(ListDataOrganizer, self).__init__(list, root, **kwargs)
def __init__(self, **kwargs):
"""Creates a new instance of MarkupTagError."""
self._errorAtEnd = ArgsUtils.extract("errorAtEnd", False, kwargs)
ArgsUtils.addIfMissing("errorDef", self.READ_FAILURE, kwargs, True)
MarkupError.__init__(self, **kwargs)
def __init__(self, parent=None, **kwargs):
"""Creates a new instance of PyGlassWebKitWidget."""
self._communicator = ArgsUtils.extract("communicator", None, kwargs)
self._debug = ArgsUtils.extract("debug", False, kwargs)
url = ArgsUtils.extract("url", None, kwargs)
localUrl = ArgsUtils.extract("localUrl", None, kwargs)
PyGlassWidget.__init__(self, parent, widgetFile=False, **kwargs)
layout = self._getLayout(self, QtGui.QVBoxLayout)
layout.setContentsMargins(0, 0, 0, 0)
self._webView = PyGlassWebView(self, communicator=self._communicator, debug=self._debug)
layout.addWidget(self._webView)
self.setLayout(layout)
if url:
self._webView.openUrl(url)
elif localUrl:
self._webView.openLocalWebUrl(url)
def send(self, cls, *args, **kwargs):
""" Sends an API request to the cloud servers and handles the response. This can be sent
either synchronously or asynchronously depending on whether or not a callback argument
is included in the request. Asynchronous requests must be handled within the context
of a running PySide application loop, as the threading is managed by PySide. """
callback = ArgsUtils.extract('callback', None, kwargs, args, 0)
if self:
return self._sendRequest(callback=callback, **kwargs)
return cls._createAndSend(callback=callback, **kwargs)
def __init__(self, parent, path, importType, session =None, analysisSession =None, **kwargs):
"""Creates a new instance of TrackImporterRemoteThread."""
self._compressed = ArgsUtils.extract('compressed', False, kwargs)
RemoteExecutionThread.__init__(self, parent, **kwargs)
self._path = path
self._session = session
self._analysisSession = analysisSession
self._importType = importType
self._verbose = ArgsUtils.get('verbose', True, kwargs)
def __init__(self, parent =None, *args, **kwargs):
"""Creates a new instance of StyledLabel."""
self._fontFamily = ArgsUtils.extract('fontFamily', None, kwargs)
self._fontSize = ArgsUtils.extract('fontSize', None, kwargs)
self._color = ArgsUtils.extract('color', None, kwargs)
self._fontWeight = ArgsUtils.extract('fontWeight', None, kwargs)
self._isItalic = ArgsUtils.extract('isItalic', None, kwargs)
self._isBold = ArgsUtils.extract('isBold', None, kwargs)
self._isBorderless = ArgsUtils.extract('isBorderless', True, kwargs)
super(StyledLabel, self).__init__(parent, *args, **kwargs)
def __init__(self, parent, toggles =False, clickOn =False, **kwargs):
"""Creates a new instance of InteractiveElement."""
self._clickCallback = ArgsUtils.extract('callback', None, kwargs)
super(InteractiveElement, self).__init__(parent, **kwargs)
self._toggles = toggles
self._clickOn = clickOn
self._checked = False
self._mode = InteractionStatesEnum.NORMAL_MODE
self._mouseEnabled = True
c = QtGui.QCursor()
c.setShape(QtCore.Qt.PointingHandCursor)
self.setCursor(c)
def createReply(cls, kind, result, errorMessage=None):
payload = result if isinstance(result, dict) else {"result": result}
warnings = ArgsUtils.extract(NimbleEnvironment.REMOTE_RESULT_WARNING_KEY, None, payload)
if errorMessage:
return NimbleResponseData(
kind=kind,
response=NimbleResponseData.FAILED_RESPONSE,
warnings=warnings,
error=errorMessage,
payload=payload,
)
return NimbleResponseData(
kind=kind, warnings=warnings, response=NimbleResponseData.SUCCESS_RESPONSE, payload=payload
)
def createReply(cls, kind, result, errorMessage=None):
payload = result if isinstance(result, dict) else {'result': result}
warnings = ArgsUtils.extract(
NimbleEnvironment.REMOTE_RESULT_WARNING_KEY, None, payload)
if errorMessage:
return NimbleResponseData(
kind=kind,
response=NimbleResponseData.FAILED_RESPONSE,
warnings=warnings,
error=errorMessage,
payload=payload)
return NimbleResponseData(kind=kind,
warnings=warnings,
response=NimbleResponseData.SUCCESS_RESPONSE,
payload=payload)
def _deployWalker(self, args, path, names):
"""Doc..."""
# Skip CDN file uploads when not walking the CDN root path explicitly
if not args['cdn'] and path.find(StaticFlowEnvironment.CDN_ROOT_PREFIX) != -1:
return
for name in names:
namePath = FileUtils.createPath(path, name)
if os.path.isdir(namePath) or StringUtils.ends(name, self._SKIP_EXTENSIONS):
continue
headersPath = namePath + '.headers'
if os.path.exists(headersPath):
headers = JSON.fromFile(headersPath)
else:
headers = dict()
if self._forceAll:
lastModified = None
elif self._forceHtml and StringUtils.ends(name, self._FORCE_HTML_EXTENSIONS):
lastModified = None
else:
lastModified = ArgsUtils.extract('_LAST_MODIFIED', None, headers)
if lastModified:
lastModified = TimeUtils.webTimestampToDateTime(lastModified)
kwargs = dict(
key=u'/' + namePath[len(self._localRootPath):].replace(u'\\', u'/').strip(u'/'),
maxAge=headers.get('max-age', -1),
eTag=headers.get('eTag', None),
expires=headers.get('Expires'),
newerThanDate=lastModified,
policy=S3Bucket.PUBLIC_READ)
if StringUtils.ends(name, self._STRING_EXTENSIONS):
result = self._bucket.put(
contents=FileUtils.getContents(namePath),
zipContents=True,
**kwargs)
else:
result = self._bucket.putFile(filename=namePath, **kwargs)
if result:
self._logger.write(u'DEPLOYED: ' + unicode(namePath) + u'->' + unicode(kwargs['key']))
def runPythonImport(cls, payload):
try:
kwargs = payload.get('kwargs', {})
targetModule = StringUtils.toStr2(payload.get('module'))
targetMethod = StringUtils.toStr2(payload.get('method'))
targetClass = StringUtils.toStr2(payload.get('class'))
target = targetClass if targetClass is not None else targetMethod
if target is None:
parts = targetModule.rsplit('.', 1)
targetModule = parts[0]
target = parts[1]
except Exception as err:
NimbleEnvironment.logError([
'ERROR: Failed to parse python import payload',
'PAYLOAD: ' + DictUtils.prettyPrint(payload)], err)
return NimbleResponseData(
kind=DataKindEnum.PYTHON_IMPORT,
error=cls._getDetailedError('\n'.join([
'ERROR: Failed to parse python import payload',
'PAYLOAD: ' + DictUtils.prettyPrint(payload)]), err),
response=NimbleResponseData.FAILED_RESPONSE)
# Dynamically import the specified module and reload it to make sure any changes have
# been updated
try:
module = __import__(
StringUtils.toStr2(targetModule),
globals(), locals(),
[StringUtils.toStr2(target)] if target else [])
reload(module)
target = getattr(module, target)
except Exception as err:
NimbleEnvironment.logError([
'ERROR: Failed to import python target',
'MODULE: %s' % targetModule,
'TARGET: %s' % target,
'PAYLOAD: ' + DictUtils.prettyPrint(payload)], err)
return NimbleResponseData(
kind=DataKindEnum.PYTHON_IMPORT,
error=cls._getDetailedError(
'Failed to import python module', err),
response=NimbleResponseData.FAILED_RESPONSE)
try:
result = dict()
if targetClass is not None:
tc = target()
result = getattr(tc, targetMethod)(**kwargs) \
if targetMethod else \
tc(**kwargs)
elif targetMethod is not None:
result = target(**kwargs)
else:
# Find a NimbleScriptBase derived class definition and if it exists, run it to
# populate the results
for name,value in DictUtils.iter(Reflection.getReflectionDict(target)):
if not inspect.isclass(value):
continue
if NimbleScriptBase in value.__bases__:
result = getattr(target, name)()(**kwargs)
found = True
# If a result dictionary contains an error key format the response as a failure
errorMessage = None
try:
errorMessage = ArgsUtils.extract(
NimbleEnvironment.REMOTE_RESULT_ERROR_KEY, None, result)
except Exception as err:
pass
return cls.createReply(DataKindEnum.PYTHON_IMPORT, result, errorMessage=errorMessage)
except Exception as err:
msg = 'ERROR: Failed to execute remote script'
NimbleEnvironment.logError([
msg,
'PAYLOAD: ' + DictUtils.prettyPrint(payload),
'TARGET: ' + str(target)], err)
return NimbleResponseData(
kind=DataKindEnum.PYTHON_IMPORT,
error=cls._getDetailedError(msg, err),
response=NimbleResponseData.FAILED_RESPONSE)
def __init__(self, *args, **kwargs):
"""Creates a new instance of SingleAttributeDataOrganizer."""
self._name = ArgsUtils.extract('name', None, kwargs, args, 0)
root = ArgsUtils.extract('root', None, kwargs, args, 1)
super(SingleAttributeDataOrganizer, self).__init__(root=root, **kwargs)
def __init__(self, parent, **kwargs):
"""Creates a new instance of AirDebugThread."""
RemoteExecutionThread.__init__(self, parent, **kwargs)
self._log.trace = True
projectPath = ArgsUtils.extract('projectPath', None, kwargs)
self._projectData = FlexProjectData(projectPath, **kwargs)
def __init__(self, *args, **kwargs):
"""Creates a new instance of SingleValuedAttributeDataOrganizer."""
self._name = ArgsUtils.extract('name', '', kwargs, args, 0)
root = ArgsUtils.extract('root', None, kwargs, args, 1)
SingleValuedDataOrganizer.__init__(self, root, **kwargs)
def __init__(self, *args, **kwargs):
"""Creates a new instance of KeyDataOrganizer."""
root = ArgsUtils.extract('root', None, kwargs, args, 0)
super(KeyDataOrganizer, self).__init__(dict, root, **kwargs)
def __init__(self, *args, **kwargs):
"""Creates a new instance of AttributeDataOrganizer."""
root = ArgsUtils.extract('root', None, kwargs, args, 0)
self._prefix = ArgsUtils.extract('prefix', '', kwargs, args, 1)
KeyDataOrganizer.__init__(self, root, **kwargs)
def runPythonImport(cls, payload):
try:
kwargs = payload.get('kwargs', {})
targetModule = StringUtils.toStr2(payload.get('module'))
targetMethod = StringUtils.toStr2(payload.get('method'))
targetClass = StringUtils.toStr2(payload.get('class'))
target = targetClass if targetClass is not None else targetMethod
if target is None:
parts = targetModule.rsplit('.', 1)
targetModule = parts[0]
target = parts[1]
except Exception as err:
NimbleEnvironment.logError([
'ERROR: Failed to parse python import payload',
'PAYLOAD: ' + DictUtils.prettyPrint(payload)
], err)
return NimbleResponseData(
kind=DataKindEnum.PYTHON_IMPORT,
error=cls._getDetailedError(
'\n'.join([
'ERROR: Failed to parse python import payload',
'PAYLOAD: ' + DictUtils.prettyPrint(payload)
]), err),
response=NimbleResponseData.FAILED_RESPONSE)
# Dynamically import the specified module and reload it to make sure any changes have
# been updated
try:
module = __import__(StringUtils.toStr2(targetModule), globals(),
locals(),
[StringUtils.toStr2(target)] if target else [])
reload(module)
target = getattr(module, target)
except Exception as err:
NimbleEnvironment.logError([
'ERROR: Failed to import python target',
'MODULE: %s' % targetModule,
'TARGET: %s' % target,
'PAYLOAD: ' + DictUtils.prettyPrint(payload)
], err)
return NimbleResponseData(
kind=DataKindEnum.PYTHON_IMPORT,
error=cls._getDetailedError('Failed to import python module',
err),
response=NimbleResponseData.FAILED_RESPONSE)
try:
result = dict()
if targetClass is not None:
tc = target()
result = getattr(tc, targetMethod)(**kwargs) \
if targetMethod else \
tc(**kwargs)
elif targetMethod is not None:
result = target(**kwargs)
else:
# Find a NimbleScriptBase derived class definition and if it exists, run it to
# populate the results
for name, value in DictUtils.iter(
Reflection.getReflectionDict(target)):
if not inspect.isclass(value):
continue
if NimbleScriptBase in value.__bases__:
result = getattr(target, name)()(**kwargs)
found = True
# If a result dictionary contains an error key format the response as a failure
errorMessage = None
try:
errorMessage = ArgsUtils.extract(
NimbleEnvironment.REMOTE_RESULT_ERROR_KEY, None, result)
except Exception as err:
pass
return cls.createReply(DataKindEnum.PYTHON_IMPORT,
result,
errorMessage=errorMessage)
except Exception as err:
msg = 'ERROR: Failed to execute remote script'
NimbleEnvironment.logError([
msg, 'PAYLOAD: ' + DictUtils.prettyPrint(payload),
'TARGET: ' + str(target)
], err)
return NimbleResponseData(
kind=DataKindEnum.PYTHON_IMPORT,
error=cls._getDetailedError(msg, err),
response=NimbleResponseData.FAILED_RESPONSE)
def __init__(self, *args, **kwargs):
"""Creates a new instance of DataListWidgetItem."""
self._itemData = ArgsUtils.extract('data', None, kwargs)
self._itemId = ArgsUtils.extract('ident', None, kwargs)
super(DataListWidgetItem, self).__init__(*args, **kwargs)
def __init__(self, **kwargs):
"""Creates a new instance of PyGlassWindow."""
parent = ArgsUtils.extract('parent', None, kwargs)
self._application = ArgsUtils.extract('pyGlassApp', None, kwargs)
self._qApplication = ArgsUtils.extract('qApp', None, kwargs)
self._isMainWindow = ArgsUtils.extract('isMainWindow', bool(parent is None), kwargs)
self._mainWindow = ArgsUtils.extract('mainWindow', None, kwargs)
self._appWrappingWidget = None
self._centerWidget = None
self._hasShown = False
self._isHighDpi = OsUtils.isHighDpiScaledScreen()
self._settings = ConfigsDict()
self._appLevelWidgets = dict()
self._appLevelWidgetDisplayHistory = []
self._keyboardCallback = ArgsUtils.extract('keyboardCallback', None, kwargs)
if not self._mainWindow:
if self._isMainWindow:
self._mainWindow = self
elif self._application:
self._mainWindow = self._application.mainWindow
self._dependentWindows = []
self._currentWidget = None
QtGui.QMainWindow.__init__(self, parent, ArgsUtils.extract('flags', 0, kwargs))
self._instanceUid = TimeUtils.getUidTimecode(
prefix=self.__class__.__name__,
suffix=StringUtils.getRandomString(8))
self._styleSheet = kwargs.get('styleSheet', None)
if self._styleSheet:
self.setStyleSheet(self.styleSheetPath)
if self._keyboardCallback is not None:
self.setFocusPolicy(QtCore.Qt.StrongFocus)
if self._isMainWindow:
self._log = Logger(self, printOut=True)
self._config = ApplicationConfig(self)
self._commonConfig = ApplicationConfig(self, common=True)
self._resourceFolderParts = PyGlassGuiUtils.getResourceFolderParts(self)
icon = PyGlassGuiUtils.createIcon(
kwargs.get('iconsPath', self.getAppResourcePath('icons', isDir=True)) )
if icon:
self.setWindowIcon(icon)
elif self._mainWindow:
icon = self._mainWindow.windowIcon()
if icon:
self.setWindowIcon(icon)
self._appWrappingWidget = VisibilityElement(self)
layout = QtGui.QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
self._appWrappingWidget.setLayout(layout)
self._contentWrappingWidget = self.addApplicationLevelWidget('main')
layout = QtGui.QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
self._contentWrappingWidget.setLayout(layout)
# Loads the ui file if it exists
externalCentralParent = None
hasWindowFile = kwargs.get('mainWindowFile', False)
if hasWindowFile == self:
UiFileLoader.loadWidgetFile(self)
externalCentralParent = getattr(self, 'windowContainer')
if externalCentralParent:
externalLayout = externalCentralParent.layout()
if not externalLayout:
externalLayout = QtGui.QVBoxLayout()
externalLayout.setContentsMargins(0, 0, 0, 0)
externalLayout.setSpacing(0)
externalCentralParent.setLayout(externalLayout)
if externalCentralParent:
self._appWrappingWidget.setParent(externalCentralParent)
externalLayout.addWidget(self._appWrappingWidget)
else:
self.setCentralWidget(self._appWrappingWidget)
# Sets a non-standard central widget
centralWidgetName = kwargs.get('centralWidgetName')
if centralWidgetName and hasattr(self, centralWidgetName):
self._centerWidget = getattr(self, centralWidgetName)
elif hasWindowFile and not hasWindowFile == self:
if not self._centerWidget:
self._createCentralWidget()
UiFileLoader.loadWidgetFile(self, target=self._centerWidget)
elif not hasWindowFile:
self._centerWidget = None
if not self._centerWidget and kwargs.get('defaultCenterWidget', True):
self._createCentralWidget()
self._lastChildWidgetID = None
self._widgetParent = None
self._widgets = None
self._widgetFlags = None
self._widgetClasses = kwargs.get('widgets', dict())
if self._widgetClasses:
self._initializeWidgetChildren()
self.setWindowTitle(kwargs.get('title', self._createTitleFromClass()))
self.updateStatusBar()
def _listPath(cls, rootPath, recursive, **kwargs):
allowDots = kwargs.get('allowDots', True)
rootPath = cls.cleanupPath(rootPath, isDir=True)
listFiles = kwargs.get('listFiles', True)
listDirs = kwargs.get('listDirs', False)
skipSVN = kwargs.get('skipSVN', True)
skips = kwargs.get('skips', None)
absolute = kwargs.get('absolute', True)
pieces = kwargs.get('pieces', False)
topPath = ArgsUtils.extract('topPath', rootPath, kwargs)
allowExtensions = ArgsUtils.getAsList('allowExtensions', kwargs)
skipExtensions = ArgsUtils.getAsList('skipExtensions', kwargs)
out = []
for item in os.listdir(rootPath):
if not allowDots and item.startswith('.'):
continue
if (skipSVN and item == '.svn') or (skips and item in skips):
continue
absItem = os.path.join(rootPath, item)
if os.path.isdir(absItem):
path = absItem + os.sep
if listDirs:
out.append(path if absolute else item)
absItem = None
if recursive:
out += cls._listPath(
rootPath=path,
recursive=recursive,
topPath=topPath, **kwargs)
elif os.path.isfile(absItem):
skip = skipExtensions and StringUtils.ends(item, skipExtensions)
if not listFiles or skip:
continue
if allowExtensions and not StringUtils.ends(item, allowExtensions):
continue
if not absItem:
continue
if not pieces and not absolute:
out.append(item)
continue
relativeItem = absItem[len(topPath):].strip(os.sep).split(os.sep)
if absolute:
relativeItem.insert(0, topPath)
if pieces:
out.append(relativeItem)
else:
out.append(os.path.join(*relativeItem))
return out
def __init__(self, **kwargs):
"""Creates a new instance of PyGlassWindow."""
parent = ArgsUtils.extract('parent', None, kwargs)
self._application = ArgsUtils.extract('pyGlassApp', None, kwargs)
self._qApplication = ArgsUtils.extract('qApp', None, kwargs)
self._isMainWindow = ArgsUtils.extract('isMainWindow', bool(parent is None), kwargs)
self._mainWindow = ArgsUtils.extract('mainWindow', None, kwargs)
self._centerWidget = None
self._keyboardCallback = ArgsUtils.extract('keyboardCallback', None, kwargs)
if not self._mainWindow:
if self._isMainWindow:
self._mainWindow = self
elif self._application:
self._mainWindow = self._application.mainWindow
self._dependentWindows = []
self._currentWidget = None
QtGui.QMainWindow.__init__(self, parent, ArgsUtils.extract('flags', 0, kwargs))
if self._keyboardCallback is not None:
self.setFocusPolicy(QtCore.Qt.StrongFocus)
if self._isMainWindow:
self._log = Logger(self, printOut=True)
self._config = ApplicationConfig(self)
self._commonConfig = ApplicationConfig(self, common=True)
self._resourceFolderParts = PyGlassGuiUtils.getResourceFolderParts(self)
icon = PyGlassGuiUtils.createIcon(
ArgsUtils.get('iconsPath', self.getAppResourcePath('icons', isDir=True), kwargs) )
if icon:
self.setWindowIcon(icon)
elif self._mainWindow:
icon = self._mainWindow.windowIcon()
if icon:
self.setWindowIcon(icon)
# Loads the ui file if it exists
hasWindowFile = ArgsUtils.get('mainWindowFile', False, kwargs)
if hasWindowFile:
if not self._centerWidget:
self._createCentralWidget()
UiFileLoader.loadWidgetFile(self, target=self._centerWidget)
self._styleSheet = ArgsUtils.get('styleSheet', None, kwargs)
if self._styleSheet:
self.setStyleSheet(self.styleSheetPath)
# Sets a non-standard central widget
centralWidgetName = ArgsUtils.get('centralWidgetName', None, kwargs)
if centralWidgetName and hasattr(self, centralWidgetName):
self._centerWidget = getattr(self, centralWidgetName)
elif not hasWindowFile:
self._centerWidget = None
if ArgsUtils.get('defaultCenterWidget', False, kwargs):
self._createCentralWidget()
self._lastWidgetID = None
self._widgetParent = None
self._widgets = None
self._widgetFlags = None
self._widgetClasses = ArgsUtils.get('widgets', None, kwargs)
if self._widgetClasses:
self._initializeWidgetChildren()
else:
self._widgetClasses = dict()
self.setWindowTitle(ArgsUtils.get('title', self._createTitleFromClass(), kwargs))
self.updateStatusBar()
def __init__(self, *args, **kwargs):
"""Creates a new instance of SingleValuedDataOrganizer."""
root = ArgsUtils.extract('root', None, kwargs, args, 0)
DomDataOrganizer.__init__(self, unicode, root, **kwargs)
def _createAndSend(cls, parent, url, callback =None, args =None, **kwargs):
dead = ArgsUtils.extract('dead', False, kwargs)
req = Request(parent=parent, url=url, args=args, dead=dead, **kwargs)
if dead:
return req.dead
return req.send(callback)
def __init__(self, id, url, **kwargs):
"""Creates a new instance of ViewRedirect."""
self.url = url
self.windowTarget = ArgsUtils.extract('windowTarget', '_blank', kwargs)
super(ViewRedirect, self).__init__(id=id, **kwargs)
def _listPath(cls, rootPath, recursive, **kwargs):
allowDots = kwargs.get('allowDots', True)
rootPath = cls.cleanupPath(rootPath, isDir=True)
listFiles = kwargs.get('listFiles', True)
listDirs = kwargs.get('listDirs', False)
skipSVN = kwargs.get('skipSVN', True)
skips = kwargs.get('skips', None)
absolute = kwargs.get('absolute', True)
pieces = kwargs.get('pieces', False)
topPath = ArgsUtils.extract('topPath', rootPath, kwargs)
allowExtensions = ArgsUtils.getAsList('allowExtensions', kwargs)
skipExtensions = ArgsUtils.getAsList('skipExtensions', kwargs)
out = []
for item in os.listdir(rootPath):
if not allowDots and item.startswith('.'):
continue
if (skipSVN and item == '.svn') or (skips and item in skips):
continue
absItem = os.path.join(rootPath, item)
if os.path.isdir(absItem):
path = absItem + os.sep
if listDirs:
out.append(path if absolute else item)
absItem = None
if recursive:
out += cls._listPath(rootPath=path,
recursive=recursive,
topPath=topPath,
**kwargs)
elif os.path.isfile(absItem):
skip = skipExtensions and StringUtils.ends(
item, skipExtensions)
if not listFiles or skip:
continue
if allowExtensions and not StringUtils.ends(
item, allowExtensions):
continue
if not absItem:
continue
if not pieces and not absolute:
out.append(item)
continue
relativeItem = absItem[len(topPath):].strip(os.sep).split(os.sep)
if absolute:
relativeItem.insert(0, topPath)
if pieces:
out.append(relativeItem)
else:
out.append(os.path.join(*relativeItem))
return out
def runPythonExec(script, kwargs=None):
from nimble.NimbleEnvironment import NimbleEnvironment
from nimble.data.NimbleResponseData import NimbleResponseData
from nimble.data.enum.DataKindEnum import DataKindEnum
try:
nimble.cmds.undoInfo(openChunk=True)
except Exception as err:
return False
try:
# Create a new, temporary module in which to run the script
module = imp.new_module('runExecTempModule')
# Initialize the script with script inputs
setattr(module, NimbleEnvironment.REMOTE_KWARGS_KEY,
kwargs if kwargs is not None else dict())
setattr(module, NimbleEnvironment.REMOTE_RESULT_KEY, dict())
# Executes the script in the new module
exec_(script, module.__dict__)
# Find a NimbleScriptBase derived class definition and if it exists, run it to populate the
# results
for name, value in Reflection.getReflectionDict(module).iteritems():
if not inspect.isclass(value):
continue
if NimbleScriptBase in value.__bases__:
getattr(module, name)().run()
break
# Retrieve the results object that contains all results set by the execution of the script
result = getattr(module, NimbleEnvironment.REMOTE_RESULT_KEY)
except Exception as err:
logger = Logger('runPythonExec', printOut=True)
logger.writeError('ERROR: Failed Remote Script Execution', err)
result = NimbleResponseData(
kind=DataKindEnum.PYTHON_SCRIPT,
response=NimbleResponseData.FAILED_RESPONSE,
error=str(err))
# If a result dictionary contains an error key format the response as a failure
try:
errorMessage = ArgsUtils.extract(
NimbleEnvironment.REMOTE_RESULT_ERROR_KEY, None, result)
if errorMessage:
return NimbleResponseData(
kind=DataKindEnum.PYTHON_SCRIPT,
response=NimbleResponseData.FAILED_RESPONSE,
error=errorMessage,
payload=result)
except Exception as err:
pass
try:
nimble.cmds.undoInfo(closeChunk=True)
except Exception as err:
return False
return result
