def launch(application): """Starts the web server that will be hosted in the Photoshop extension. """ from avalon import api, photoshop api.install(photoshop) # Launch Photoshop and the html server. process = subprocess.Popen(application, stdout=subprocess.PIPE) server = html_server.app.start_server(5000) # Wait for application launch to show Workfiles. if os.environ.get("AVALON_PHOTOSHOP_WORKFILES_ON_LAUNCH", False): # Wait for Photoshop launch. if photoshop.app(): workfiles.show(save=False) # Wait for Photoshop launch. if photoshop.app(): api.emit("application.launched") self.callback_queue = queue.Queue() while True: main_thread_listen() # Wait on Photoshop to close before closing the html server. process.wait() server.shutdown()
def launch(*subprocess_args): """Starts the websocket server that will be hosted in the Photoshop extension. """ from avalon import api, photoshop api.install(photoshop) sys.excepthook = safe_excepthook # Launch Photoshop and the websocket server. process = subprocess.Popen(subprocess_args, stdout=subprocess.PIPE) websocket_server = WebServerTool() # Add Websocket route websocket_server.add_route("*", "/ws/", WebSocketAsync) # Add after effects route to websocket handler route_name = 'Photoshop' print("Adding {} route".format(route_name)) WebSocketAsync.add_route( route_name, PhotoshopRoute # keep same name as in extension ) websocket_server.start_server() while True: if process.poll() is not None: print("Photoshop process is not alive. Exiting") websocket_server.stop() sys.exit(1) try: _stub = photoshop.stub() if _stub: break except Exception: time.sleep(0.5) # Wait for application launch to show Workfiles. if os.environ.get("AVALON_PHOTOSHOP_WORKFILES_ON_LAUNCH", True): if os.getenv("WORKFILES_SAVE_AS"): workfiles.show(save=False) else: workfiles.show() # Photoshop could be closed immediately, withou workfile selection try: if photoshop.stub(): api.emit("application.launched") self.callback_queue = queue.Queue() while True: main_thread_listen(process, websocket_server) except ConnectionNotEstablishedYet: pass finally: # Wait on Photoshop to close before closing the websocket server process.wait() websocket_server.stop()
def launch(application_path): """Setup for Storyboard Pro launch.""" from avalon import api, storyboardpro, toonboom api.install(storyboardpro) toonboom.launch( application_path, os.path.join(os.path.dirname(__file__), "temp.zip") )
def main(env): import openpype.hosts.resolve as bmdvr # Registers openpype's Global pyblish plugins openpype.install() # activate resolve from openpype avalon.install(bmdvr) log.info(f"Avalon registred hosts: {avalon.registered_host()}") bmdvr.launch_pype_menu()
def main(launch_args): # Be sure server won't crash at any moment but just print traceback sys.excepthook = safe_excepthook # Create QtApplication for tools # - QApplicaiton is also main thread/event loop of the server qt_app = QtWidgets.QApplication([]) # Execute pipeline installation api.install(tvpaint) # Create Communicator object and trigger launch # - this must be done before anything is processed communicator = CommunicationWrapper.create_communicator(qt_app) communicator.launch(launch_args) def process_in_main_thread(): """Execution of `MainThreadItem`.""" item = communicator.main_thread_listen() if item: item.execute() timer = QtCore.QTimer() timer.setInterval(100) timer.timeout.connect(process_in_main_thread) timer.start() # Register terminal signal handler def signal_handler(*_args): print("You pressed Ctrl+C. Process ended.") communicator.stop() signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) qt_app.setQuitOnLastWindowClosed(False) qt_app.setStyleSheet(style.load_stylesheet()) # Load avalon icon icon_path = get_icon_path() if icon_path: icon = QtGui.QIcon(icon_path) qt_app.setWindowIcon(icon) # Set application name to be able show application icon in task bar if platform.system().lower() == "windows": ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID( u"WebsocketServer") # Run Qt application event processing sys.exit(qt_app.exec_())
def publish(paths, gui=False): """Publish rendered image sequences based on the job data Args: paths (list): a list of paths where to publish from gui (bool, Optional): Choose to show Pyblish GUI, default is False Returns: None """ assert isinstance(paths, (list, tuple)), "Must be list of paths" log.info(paths) assert any(paths), "No paths found in the list" # Set the paths to publish for the collector if any provided if paths: os.environ["FILESEQUENCE"] = os.pathsep.join(paths) # Install Avalon with shell as current host from avalon import api, shell api.install(shell) # Register target and host import pyblish.api pyblish.api.register_target("filesequence") pyblish.api.register_host("shell") # Publish items if gui: import pyblish_qml pyblish_qml.show(modal=True) else: import pyblish.util context = pyblish.util.publish() if not context: log.warning("Nothing collected.") sys.exit(1) # Collect errors, {plugin name: error} error_results = [r for r in context.data["results"] if r["error"]] if error_results: log.error(" Errors occurred ...") for result in error_results: log.error(error_format.format(**result)) sys.exit(2)
def launch(self, launch_args): """Prepare all required data and launch host. First is prepared websocket server as communication point for host, when server is ready to use host is launched as subprocess. """ log.info("Installing TVPaint implementation") api.install(tvpaint) if platform.system().lower() == "windows": self._prepare_windows_plugin(launch_args) # Launch TVPaint and the websocket server. log.info("Launching TVPaint") self.websocket_server = WebSocketServer() self.websocket_rpc = TVPaintRpc(self, loop=self.websocket_server.loop) os.environ["WEBSOCKET_URL"] = "ws://localhost:{}".format( self.websocket_server.port) self.websocket_server.add_route("*", "/", self.websocket_rpc.handle_request) log.info("Added request handler for url: {}".format( os.environ["WEBSOCKET_URL"])) self.websocket_server.start() # Make sure RPC is using same loop as websocket server while not self.websocket_server.server_is_running: time.sleep(0.1) # Start TVPaint when server is running self._launch_tv_paint(launch_args) log.info("Waiting for client connection") while True: if self.process.poll() is not None: log.debug("Host process is not alive. Exiting") self.websocket_server.stop() self.qt_app.quit() return if self.websocket_rpc.client_connected(): log.info("Client has connected") break time.sleep(0.5) self.on_client_connect() api.emit("application.launched")
def launch(application): """Starts the web server that will be hosted in the Photoshop extension. """ from avalon import api, photoshop api.install(photoshop) sys.excepthook = safe_excepthook # Launch Photoshop and the html server. process = subprocess.Popen(application, stdout=subprocess.PIPE) server = html_server.app.start_server(5000) while True: if process.poll() is not None: print("Photoshop process is not alive. Exiting") server.shutdown() sys.exit(1) try: _app = photoshop.app() if _app: break except Exception: time.sleep(0.1) # Wait for application launch to show Workfiles. if os.environ.get("AVALON_PHOTOSHOP_WORKFILES_ON_LAUNCH", False): # Wait for Photoshop launch. if photoshop.app(): workfiles.show(save=False) # Wait for Photoshop launch. if photoshop.app(): api.emit("application.launched") self.callback_queue = queue.Queue() while True: main_thread_listen() # Wait on Photoshop to close before closing the html server. process.wait() server.shutdown()
def launch(*subprocess_args): """Starts the websocket server that will be hosted in the Photoshop extension. """ from avalon import api, photoshop api.install(photoshop) sys.excepthook = safe_excepthook # Launch Photoshop and the websocket server. ConsoleTrayApp.process = subprocess.Popen( subprocess_args, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL ) websocket_server = WebServerTool() route_name = 'Photoshop' if websocket_server.port_occupied(websocket_server.host_name, websocket_server.port): log.info("Server already running, sending actual context and exit") asyncio.run(websocket_server.send_context_change(route_name)) sys.exit(1) # Add Websocket route websocket_server.add_route("*", "/ws/", WebSocketAsync) # Add after effects route to websocket handler print("Adding {} route".format(route_name)) WebSocketAsync.add_route( route_name, PhotoshopRoute # keep same name as in extension ) websocket_server.start_server() ConsoleTrayApp.websocket_server = websocket_server if os.environ.get("AVALON_PHOTOSHOP_WORKFILES_ON_LAUNCH", True): save = False if os.getenv("WORKFILES_SAVE_AS"): save = True ConsoleTrayApp.execute_in_main_thread(lambda: workfiles.show(save))
def reload_pipeline(): """Attempt to reload pipeline at run-time. CAUTION: This is primarily for development and debugging purposes. """ import importlib import pype.hosts.premiere api.uninstall() for module in ("avalon.io", "avalon.lib", "avalon.pipeline", "avalon.api", "avalon.tools", "{}".format(AVALON_CONFIG), "{}.premiere".format(AVALON_CONFIG), "{}.premiere.lib".format(AVALON_CONFIG)): log.info("Reloading module: {}...".format(module)) try: module = importlib.import_module(module) importlib.reload(module) except Exception as e: log.warning("Cannot reload module: {}".format(e)) api.install(pype.hosts.premiere)
update_frame_range(current_comp, representations) current_comp.Save(comp_path) return comp_path if __name__ == '__main__': import argparse parser = argparse.ArgumentParser(description="Switch to a shot within an" "existing comp file") parser.add_argument("--file_path", type=str, default=True, help="File path of the comp to use") parser.add_argument("--asset_name", type=str, default=True, help="Name of the asset (shot) to switch") args, unknown = parser.parse_args() api.install(avalon.fusion) switch(args.asset_name, args.file_path) sys.exit(0)
def main(): print("Installing OpenPype ...") api.install(houdini)
def register(): """Register Avalon with Blender.""" print("Registering Avalon...") api.install(blender)
def main(): print("Installing Avalon ...") api.install(houdini)
import unreal avalon_detected = True try: from avalon import api from avalon import unreal as avalon_unreal except ImportError as exc: avalon_detected = False unreal.log_error("Avalon: cannot load avalon [ {} ]".format(exc)) if avalon_detected: api.install(avalon_unreal) @unreal.uclass() class AvalonIntegration(unreal.AvalonPythonBridge): @unreal.ufunction(override=True) def RunInPython_Create(self): unreal.log_warning("Avalon: showing creator window") if avalon_detected: avalon_unreal.show_creator() @unreal.ufunction(override=True) def RunInPython_Load(self): unreal.log_warning("Avalon: showing loader window") if avalon_detected: avalon_unreal.show_loader() @unreal.ufunction(override=True) def RunInPython_Publish(self):
def __init__(self): super(ThisTestGUI, self).__init__() # Registers openpype's Global pyblish plugins openpype.install() # activate resolve from openpype avalon.install(bmdvr)
from avalon import api, maya api.install(maya)
def install(self): """Ensure the plugins have been registered together with a host name""" import avalon.shell api.install(avalon.shell) pyblish.api.register_host("shell")