def location_configuration_finished(self, reconfigure_session=True):
'''Continue connect setup after location configuration is done.'''
if reconfigure_session:
ftrack_connect.session.destroy_shared_session()
self._session = self._setup_session()
try:
self.configureConnectAndDiscoverPlugins()
except Exception as error:
self.logger.exception(u'Error during location configuration.:')
self._report_session_setup_error(error)
else:
self.focus()
# Send verify startup event to verify that storage scenario is
# working correctly.
event = ftrack_api.event.base.Event(
topic='ftrack.connect.verify-startup',
data={
'storage_scenario': self._session.server_information.get(
'storage_scenario'
)
}
)
results = self._session.event_hub.publish(event, synchronous=True)
problems = [
problem for problem in results if isinstance(problem, basestring)
]
if problems:
msgBox = QtWidgets.QMessageBox(parent=self)
msgBox.setIcon(QtWidgets.QMessageBox.Warning)
msgBox.setText('\n\n'.join(problems))
msgBox.exec_()
def create_missing_asset(self):
'''Trigger creation of missing assets.'''
sender = self.sender()
asset_type = sender.text()
self._session.ensure('AssetType', {
'short': asset_type.lower(),
'name': asset_type
})
try:
self._session.commit()
except Exception as error:
QtWidgets.QMessageBox().critical(self, 'ERROR', str(error))
return
sender.setDisabled(True)
def removeObject(self, objectName):
'''Remove object with *objectName* from scene.'''
msgBox = QtWidgets.QMessageBox()
msgBox.setText('Remove asset.')
msgBox.setInformativeText('Are you sure you want to remove the asset?')
msgBox.setStandardButtons(QtWidgets.QMessageBox.Ok
| QtWidgets.QMessageBox.Cancel)
msgBox.setDefaultButton(QtWidgets.QMessageBox.Ok)
ret = msgBox.exec_()
if ret == QtWidgets.QMessageBox.Ok:
self.connector.removeObject(applicationObject=objectName)
foundItem = self.ui.AssertManagerTableWidget.findItems(
objectName, QtCore.Qt.MatchExactly)
self.ui.AssertManagerTableWidget.removeRow(foundItem[0].row())
self.refreshAssetManager()
def _onLoggingButtonClicked(self):
'''Handle logging button clicked.'''
directory = get_log_directory()
if not os.path.exists(directory):
# Create directory if not existing.
try:
os.makedirs(directory)
except OSError:
messageBox = QtWidgets.QMessageBox(parent=self)
messageBox.setIcon(QtWidgets.QMessageBox.Warning)
messageBox.setText(
u'Could not open or create logging '
u'directory: {0}.'.format(directory)
)
messageBox.exec_()
return
ftrack_connect.util.open_directory(directory)
def doit(self):
'''' Execute action. '''
selection = self.getTrackItems()
sequence = hiero.ui.activeView().sequence()
project = sequence.project()
if not self.configure(project, selection):
return
self._buildTrack(selection, sequence, project)
if self._errors:
msgBox = QtWidgets.QMessageBox(hiero.ui.mainWindow())
msgBox.setWindowTitle('Build track from ftrack')
msgBox.setText('There were problems building the track.')
msgBox.setDetailedText('\n'.join(self._errors))
msgBox.exec_()
self._errors = []
def openDefaultPluginDirectory(self):
'''Open default plugin directory in platform default file browser.'''
directory = self.defaultPluginDirectory
if not os.path.exists(directory):
# Create directory if not existing.
try:
os.makedirs(directory)
except OSError:
messageBox = QtWidgets.QMessageBox(parent=self)
messageBox.setIcon(QtWidgets.QMessageBox.Warning)
messageBox.setText(
u'Could not open or create default plugin '
u'directory: {0}.'.format(directory)
)
messageBox.exec_()
return
ftrack_connect.util.open_directory(directory)
def validate_ftrack_processing(self, export_items, preview):
''' Return whether the *export_items* and processor are valid to be rendered.
In *preview* will not go through the whole validation, and return False by default.
'''
task_type = self._preset.properties()['ftrack']['task_type']
asset_type_name = self._preset.properties(
)['ftrack']['asset_type_name']
asset_name = self._preset.properties()['ftrack']['asset_name']
for (export_path, preset) in self._exportTemplate.flatten():
# Propagate properties from processor to tasks.
preset.properties()['ftrack']['task_type'] = task_type
preset.properties()['ftrack']['asset_type_name'] = asset_type_name
preset.properties()['ftrack']['asset_name'] = asset_name
if preview:
return False
else:
self._validate_project_progress_widget = foundry.ui.ProgressTask(
'Validating settings.')
errors = {}
missing_assets_type = []
duplicated_components = []
non_matching_template_items = []
num_items = len(self._exportTemplate.flatten()) + len(export_items)
progress_index = 0
for exportItem in export_items:
item = exportItem.item()
# Skip effects track items.
if isinstance(
item,
(hiero.core.EffectTrackItem, hiero.core.Transition)):
self.logger.debug('Skipping {0}'.format(item))
continue
project = item.project()
parsing_template = template_manager.get_project_template(
project)
task_tags = set()
task_types = self.schema(project).get_types('Task')
try:
template_manager.match(item, parsing_template)
except ftrack_connect_nuke_studio.exception.TemplateError:
self.logger.warning(
'Skipping {} as does not match {}'.format(
item, parsing_template['expression']))
if item not in non_matching_template_items:
non_matching_template_items.append(item.name())
continue
if not hasattr(item, 'tags'):
continue
for tag in item.tags():
meta = tag.metadata()
if meta.hasKey('type') and meta.value('type') == 'ftrack':
task_name = meta.value('ftrack.name')
filtered_task_types = [
task_type for task_type in task_types
if (task_type['name'] == task_name)
]
if len(filtered_task_types) == 1:
task_tags.add(task_name)
components = []
for (export_path, preset) in self._exportTemplate.flatten():
# Build TaskData seed
taskData = hiero.core.TaskData(
preset,
item,
preset.properties()['exportRoot'],
export_path,
'v0',
self._exportTemplate,
project=item.project(),
resolver=self._preset.createResolver())
task = hiero.core.taskRegistry.createTaskFromPreset(
preset, taskData)
self.logger.info(
'Getting preset {} for deduplication'.format(
task.component_name()))
if task.component_name() not in components:
components.append(task.component_name())
else:
duplicated_components.append(
(task.component_name(), task))
progress_index += 1
self._validate_project_progress_widget.setProgress(
int(100.0 *
(float(progress_index) / float(num_items))))
asset_type_name = preset.properties(
)['ftrack']['asset_type_name']
ftrack_asset_type = self.session.query(
'AssetType where short is "{0}"'.format(
asset_type_name)).first()
if not ftrack_asset_type and asset_type_name not in missing_assets_type:
missing_assets_type.append(asset_type_name)
try:
result = self.task_type(project)
except FtrackProcessorValidationError as error:
preset_errors = errors.setdefault(self, {})
preset_errors.setdefault('task_type', list(task_tags))
self._validate_project_progress_widget = None
# Raise validation window.
if errors or missing_assets_type or duplicated_components:
settings_validator = FtrackSettingsValidator(
self.session, errors, missing_assets_type,
duplicated_components)
if settings_validator.exec_() != QtWidgets.QDialog.Accepted:
return False
self.validate_ftrack_processing(export_items, preview)
# Raise notification for error parsing items.
if non_matching_template_items:
item_warning = QtWidgets.QMessageBox().warning(
None, 'Error parsing Track Items',
'Some items failed to parse and will not be published\n'
'{} do you want to continue with the others ?'.format(
', '.join(non_matching_template_items)),
QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
if item_warning != QtWidgets.QMessageBox.Yes:
return False
else:
# user has been notified, and want to go ahead....
non_matching_template_items = []
return True
