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)