def save_studio_settings(data):
"""Save studio overrides of system settings.
Triggers callbacks on modules that want to know about system settings
changes.
Callbacks are triggered on all modules. They must check if their enabled
value has changed.
For saving of data cares registered Settings handler.
Args:
data(dict): Overrides data with metadata defying studio overrides.
"""
# Notify Pype modules
from pype.modules import ModulesManager, ISettingsChangeListener
old_data = get_system_settings()
default_values = get_default_settings()[SYSTEM_SETTINGS_KEY]
new_data = apply_overrides(default_values, copy.deepcopy(data))
clear_metadata_from_settings(new_data)
changes = calculate_changes(old_data, new_data)
modules_manager = ModulesManager(_system_settings=new_data)
for module in modules_manager.get_enabled_modules():
if isinstance(module, ISettingsChangeListener):
module.on_system_settings_save(old_data, new_data, changes)
return _SETTINGS_HANDLER.save_studio_settings(data)
def paths_to_launch_hooks(self):
"""Directory paths where to look for launch hooks."""
# This method has potential to be part of application manager (maybe).
paths = []
# TODO load additional studio paths from settings
import pype
pype_dir = os.path.dirname(os.path.abspath(pype.__file__))
# --- START: Backwards compatibility ---
hooks_dir = os.path.join(pype_dir, "hooks")
subfolder_names = ["global", self.host_name]
for subfolder_name in subfolder_names:
path = os.path.join(hooks_dir, subfolder_name)
if (os.path.exists(path) and os.path.isdir(path)
and path not in paths):
paths.append(path)
# --- END: Backwards compatibility ---
subfolders_list = (["hooks"], ("hosts", self.host_name, "hooks"))
for subfolders in subfolders_list:
path = os.path.join(pype_dir, *subfolders)
if (os.path.exists(path) and os.path.isdir(path)
and path not in paths):
paths.append(path)
# Load modules paths
from pype.modules import ModulesManager
manager = ModulesManager()
paths.extend(manager.collect_launch_hook_paths())
return paths
def set_modules_environments():
"""Set global environments for pype modules.
This requires to have pype in `sys.path`.
"""
from pype.modules import ModulesManager
import acre
modules_manager = ModulesManager()
module_envs = modules_manager.collect_global_environments()
publish_plugin_dirs = modules_manager.collect_plugin_paths()["publish"]
# Set pyblish plugins paths if any module want to register them
if publish_plugin_dirs:
publish_paths_str = os.environ.get("PYBLISHPLUGINPATH") or ""
publish_paths = publish_paths_str.split(os.pathsep)
_publish_paths = {
os.path.normpath(path) for path in publish_paths if path
}
for path in publish_plugin_dirs:
_publish_paths.add(os.path.normpath(path))
module_envs["PYBLISHPLUGINPATH"] = os.pathsep.join(_publish_paths)
# Merge environments with current environments and update values
if module_envs:
parsed_envs = acre.parse(module_envs)
env = acre.merge(parsed_envs, dict(os.environ))
os.environ.clear()
os.environ.update(env)
def main(args):
port = int(args[-1])
# Create a TCP/IP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Connect the socket to the port where the server is listening
server_address = ("localhost", port)
log.debug("Processor connected to {} port {}".format(*server_address))
sock.connect(server_address)
sock.sendall(b"CreatedProcess")
returncode = 0
try:
session = SocketSession(auto_connect_event_hub=True,
sock=sock,
Eventhub=ProcessEventHub)
register(session)
SessionFactory.session = session
manager = ModulesManager()
ftrack_module = manager.modules_by_name["ftrack"]
server = FtrackServer(ftrack_module.server_event_handlers_paths)
log.debug("Launched Ftrack Event processor")
server.run_server(session)
except Exception:
returncode = 1
log.error("Event server crashed. See traceback below", exc_info=True)
finally:
log.debug("First closing socket")
sock.close()
return returncode
def main(args):
port = int(args[-1])
# Create a TCP/IP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Connect the socket to the port where the server is listening
server_address = ("localhost", port)
log.debug(
"User Ftrack Server connected to {} port {}".format(*server_address)
)
sock.connect(server_address)
sock.sendall(b"CreatedUser")
try:
session = SocketSession(
auto_connect_event_hub=True, sock=sock, Eventhub=SocketBaseEventHub
)
manager = ModulesManager()
ftrack_module = manager.modules_by_name["ftrack"]
ftrack_module.user_event_handlers_paths
server = FtrackServer(
ftrack_module.user_event_handlers_paths
)
log.debug("Launching User Ftrack Server")
server.run_server(session=session)
except Exception:
log.warning("Ftrack session server failed.", exc_info=True)
finally:
log.debug("Closing socket")
sock.close()
return 1
def main():
os.environ["AVALON_APP"] = HOST_NAME
# Allow to change icon of running process in windows taskbar
if os.name == "nt":
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
u"standalonepublish")
qt_app = QtWidgets.QApplication([])
# app.setQuitOnLastWindowClosed(False)
qt_app.setStyleSheet(style.load_stylesheet())
icon = QtGui.QIcon(resources.pype_icon_filepath())
qt_app.setWindowIcon(icon)
def signal_handler(sig, frame):
print("You pressed Ctrl+C. Process ended.")
qt_app.quit()
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
modules_manager = ModulesManager()
module = modules_manager.modules_by_name["standalonepublish_tool"]
window = Window(module.publish_paths)
window.show()
sys.exit(qt_app.exec_())
def main(args):
check_thread = None
try:
manager = ModulesManager()
ftrack_module = manager.modules_by_name["ftrack"]
server = FtrackServer(ftrack_module.server_event_handlers_paths)
session = ftrack_api.Session(auto_connect_event_hub=True)
check_thread = TimerChecker(server, session)
check_thread.start()
log.debug("Launching Ftrack Event Legacy Server")
server.run_server(session)
except Exception as exc:
import traceback
traceback.print_tb(exc.__traceback__)
finally:
log_info = True
if check_thread is not None:
check_thread.stop()
check_thread.join()
if check_thread.failed:
log_info = False
if log_info:
log.info("Exiting Event server subprocess")
return 1
def save_project_anatomy(project_name, anatomy_data):
"""Save studio overrides of project anatomy.
Old value, new value and changes are passed to enabled modules that want to
know about settings changes.
For saving of data cares registered Settings handler.
Args:
project_name (str): Project name for which overrides are passed.
Default project's value is None.
overrides(dict): Overrides data with metadata defying studio overrides.
"""
# Notify Pype modules
from pype.modules import ModulesManager, ISettingsChangeListener
default_values = get_default_settings()[PROJECT_ANATOMY_KEY]
if project_name:
old_data = get_anatomy_settings(project_name)
studio_overrides = get_studio_project_settings_overrides()
studio_values = apply_overrides(default_values, studio_overrides)
clear_metadata_from_settings(studio_values)
new_data = apply_overrides(studio_values, copy.deepcopy(anatomy_data))
else:
old_data = get_default_anatomy_settings(exclude_locals=True)
new_data = apply_overrides(default_values, copy.deepcopy(anatomy_data))
clear_metadata_from_settings(new_data)
changes = calculate_changes(old_data, new_data)
modules_manager = ModulesManager()
for module in modules_manager.get_enabled_modules():
if isinstance(module, ISettingsChangeListener):
module.on_project_anatomy_save(old_data, new_data, changes,
project_name)
return _SETTINGS_HANDLER.save_project_anatomy(project_name, anatomy_data)
def __init__(self, parent=None):
super(LocalSettingsWidget, self).__init__(parent)
self.system_settings = SystemSettings()
self.project_settings = ProjectSettings()
self.modules_manager = ModulesManager()
self.main_layout = QtWidgets.QVBoxLayout(self)
self.pype_mongo_widget = None
self.general_widget = None
self.apps_widget = None
self.projects_widget = None
self._create_pype_mongo_ui()
self._create_general_ui()
self._create_app_ui()
self._create_project_ui()
# Add spacer to main layout
self.main_layout.addWidget(SpacerWidget(self), 1)