def tearDown(self): """ Cleans up after tests. """ self._tear_down_called = True try: sgtk.set_authenticated_user(self._authenticated_user) # get rid of path cache from local ~/.shotgun storage if self._do_io: pc = path_cache.PathCache(self.tk) path_cache_file = pc._get_path_cache_location() pc.close() if os.path.exists(path_cache_file): os.remove(path_cache_file) # get rid of init cache if os.path.exists(pipelineconfig_factory._get_cache_location()): os.remove(pipelineconfig_factory._get_cache_location()) # move project scaffold out of the way self._move_project_data() # important to delete this to free memory self.tk = None # clear global shotgun accessor tank.util.shotgun.connection._g_sg_cached_connections = threading.local() finally: if self._old_shotgun_home is not None: os.environ[self.SHOTGUN_HOME] = self._old_shotgun_home else: del os.environ[self.SHOTGUN_HOME]
def tearDown(self): """ Cleans up after tests. """ try: sgtk.set_authenticated_user(self._authenticated_user) # get rid of path cache from local ~/.shotgun storage pc = path_cache.PathCache(self.tk) path_cache_file = pc._get_path_cache_location() pc.close() if os.path.exists(path_cache_file): os.remove(path_cache_file) # clear global shotgun accessor tank.util.shotgun._g_sg_cached_connections = threading.local() # get rid of init cache if os.path.exists(pipelineconfig_factory._get_cache_location()): os.remove(pipelineconfig_factory._get_cache_location()) # move project scaffold out of the way self._move_project_data() # important to delete this to free memory self.tk = None finally: if self._old_shotgun_home is not None: os.environ[self.SHOTGUN_HOME] = self._old_shotgun_home else: del os.environ[self.SHOTGUN_HOME]
def start_engine(data): """ Start the tk-desktop engine given a data dictionary like the one passed to the launch_python hook. """ sys.path.append(data["core_python_path"]) # make sure we don't inherit the GUI's pipeline configuration os.environ["TANK_CURRENT_PC"] = data["config_path"] import sgtk sgtk.util.append_path_to_env_var("PYTHONPATH", data["core_python_path"]) # If the core supports the shotgun_authentication module and the pickle has # a current user, we have to set the authenticated user. if hasattr(sgtk, "set_authenticated_user"): # Retrieve the currently authenticated user for this process. from tank_vendor.shotgun_authentication import ShotgunAuthenticator user = ShotgunAuthenticator(sgtk.util.CoreDefaultsManager()).get_default_user() sgtk.set_authenticated_user(user) tk = sgtk.sgtk_from_path(data["config_path"]) tk._desktop_data = data["proxy_data"] ctx = tk.context_from_entity("Project", data["project"]["id"]) return sgtk.platform.start_engine("tk-desktop", tk, ctx)
def sgwi(): """ Shotgun with authentification""" import sgtk from tank_vendor.shotgun_authentication import ShotgunAuthenticator cdm = sgtk.util.CoreDefaultsManager() authenticator = ShotgunAuthenticator(cdm) user = authenticator.create_script_user(api_script="Toolkit",api_key="cdeb3545052b2afeec449c43deda7c857558a067658b52033ce489d0789d6aff") sgtk.set_authenticated_user(user) return sgtk.sgtk_from_path(cf.get_primary_data_root())
def test_01_setup_legacy_bootstrap_core(self): """ Sets up a site-wide configuration like Shotgun Desktop 1.3.6 used to do so we can make sure it doesn't get broken by more recent versions of tk-core. """ self.remove_files(self.legacy_bootstrap_core, self.site_config_location) if sys.platform == "darwin": path_param = "config_path_mac" elif sys.platform == "win32": path_param = "config_path_win" elif sys.platform.startswith("linux"): path_param = "config_path_linux" cw = sgtk.bootstrap.configuration_writer.ConfigurationWriter( sgtk.util.ShotgunPath.from_current_os_path( self.legacy_bootstrap_core), self.sg) # Activate the core. cw.ensure_project_scaffold() install_core_folder = os.path.join(self.legacy_bootstrap_core, "install", "core") os.makedirs(install_core_folder) cw.write_shotgun_file(Mock(get_path=lambda: "does_not_exist")) cw.write_install_location_file() sgtk.util.filesystem.copy_folder(self.tk_core_repo_root, install_core_folder, skip_list=[".git", "docs", "tests"]) cw.create_tank_command() # Setup the site config in the legacy auto_path mode that the Desktop used. params = { "auto_path": True, "config_uri": os.path.join(os.path.dirname(__file__), "data", "site_config"), "project_folder_name": "site", "project_id": None, path_param: self.site_config_location, } setup_project = sgtk.get_command("setup_project") setup_project.set_logger(logger) sgtk.set_authenticated_user(self.user) with patch("tank.pipelineconfig_utils.resolve_all_os_paths_to_core", return_value=sgtk.util.ShotgunPath.from_current_os_path( self.legacy_bootstrap_core).as_system_dict()): setup_project.execute(params)
def setUp( self, app_instance="tk-multi-workfiles2", work_template="sandbox_path", publish_template="publish_path", ): """ Fixtures setup """ # Make sure the project folder on disk has a unique name between each test. super(Workfiles2TestBase, self).setUp({"project_tank_name": self.short_test_name}) sgtk.set_authenticated_user(SealedMock(login="******")) self.jeff = self.mockgun.create("HumanUser", { "name": "Jeff", "login": "******" }) self.francis = self.mockgun.create("HumanUser", { "name": "Francis", "login": "******" }) self.rob = self.mockgun.create("HumanUser", { "name": "Rob", "login": "******" }) self.setup_fixtures() # Add these to mocked shotgun self.add_to_sg_mock_db([self.project]) # run folder creation for the project self.tk.create_filesystem_structure(self.project["type"], self.project["id"]) # now make a context context = self.tk.context_from_entity(self.project["type"], self.project["id"]) # and start the engine self.engine = sgtk.platform.start_engine("tk-testengine", self.tk, context) # This ensures that the engine will always be destroyed. self.addCleanup(self.engine.destroy) self.app = self.engine.apps[app_instance] self.tk_multi_workfiles = self.app.import_module("tk_multi_workfiles") self.bg_task_manager = ( self.app.frameworks["tk-framework-shotgunutils"].import_module( "task_manager").BackgroundTaskManager(parent=None, start_processing=True)) self.addCleanup(self.bg_task_manager.shut_down) self.work_template = self.tk.templates[work_template] self.publish_template = self.tk.templates[publish_template]
def test_01_setup_legacy_bootstrap_core(self): """ Test payload. See class docstring for details. """ if sys.platform == "darwin": path_param = "config_path_mac" elif sys.platform == "win32": path_param = "config_path_win" elif sys.platform.startswith("linux"): path_param = "config_path_linux" # create a basic install that we can run setup_project from install_location = os.path.join(self.temp_dir, "preflight_install") self._create_basic_install(install_location) # Now run setup_project for the basic config params = { "config_uri": "tk-config-basic", "force": True, "project_folder_name": "bootstrap_test", "project_id": self.project["id"], path_param: self.installed_config_location, } setup_project = sgtk.get_command("setup_project") setup_project.set_logger(logger) sgtk.set_authenticated_user(self.user) with patch("tank.pipelineconfig_utils.resolve_all_os_paths_to_core", return_value=sgtk.util.ShotgunPath.from_current_os_path( install_location).as_system_dict()): setup_project.execute(params) # Find the project and pipeline configuration in Shotgun. project = self.sg.find_one("Project", [["id", "is", self.project["id"]]]) pc = self.sg.find_one( "PipelineConfiguration", [["code", "is", "Primary"], ["project", "is", project]]) # Bootstrap into the tk-shell123 engine. manager = sgtk.bootstrap.ToolkitManager(self.user) manager.pipeline_configuration = pc["id"] try: engine = manager.bootstrap_engine("tk-shell123", project) except Exception as e: # note: due to core swapping this comparison needs to happen by name self.assertEqual(e.__class__.__name__, sgtk.platform.TankMissingEngineError.__name__) engine = manager.bootstrap_engine("tk-shell", project) self.assertEqual(engine.name, "tk-shell")
def init_user_credentials(): """ Initialize the user credentials for Toolkit """ # Initialize shotgun authentication core_dm = sgtk.authentication.CoreDefaultsManager() shotgun_authenticator = sgtk.authentication.ShotgunAuthenticator(core_dm) user = shotgun_authenticator.get_user() if user.are_credentials_expired(): # If they are, we will clear them from the session cache... shotgun_authenticator.clear_default_user() user = shotgun_authenticator.get_user() sgtk.set_authenticated_user(user)
def get_file_path(sg, project, version): # Use the authenticator to create a user object. This object # identifies a Shotgun user or script and also wraps around # a Shotgun API instance which is associated with that user sa = sgtk.authentication.ShotgunAuthenticator() script_user = sa.create_script_user(api_script=SCRIPT_NAME, api_key=SCRIPT_KEY, host=SERVER) sgtk.set_authenticated_user(script_user) # get toolkit manager mgr = sgtk.bootstrap.ToolkitManager(sg_user=script_user) mgr.plugin_id = "basic.*" project_id = project.get("id") engine = mgr.bootstrap_engine("tk-shell", entity={"type": "Project", "id": project_id}) tk = engine.sgtk # get all required fields to fill temolate sg_asset_type = sg.find_one( "Asset", [["id", "is", version["entity"]["id"]]], ["sg_asset_type"] )["sg_asset_type"] step_id = sg.find_one( "Task", [["id", "is", version["sg_task"]["id"]]], ["step"] )["step"]["id"] step = sg.find_one( "Step", [["id", "is", step_id]], ["short_name"] )["short_name"] version_name = version["code"].split(".") name = version_name[0].split("_")[-1] version_number = version_name[1] if version_number.startswith("v"): version_number = version_number[1:] work_fields = { "Asset": version["entity"]["name"], "sg_asset_type": sg_asset_type, "Step": step, "name": name, "version": int(version_number), } ps_template = tk.templates["photoshop_asset_work"] path = ps_template.apply_fields(work_fields) engine.ensure_folder_exists(os.path.dirname(path)) # destroy engine engine.destroy() return path
def test_01_setup_legacy_bootstrap_core(self): """ Test payload. See class docstring for details. """ if sys.platform == "darwin": path_param = "config_path_mac" elif sys.platform == "win32": path_param = "config_path_win" elif sys.platform.startswith("linux"): path_param = "config_path_linux" # create a basic install that we can run setup_project from install_location = os.path.join(self.temp_dir, "preflight_install") self._create_basic_install(install_location) # Now run setup_project for the basic config params = { "config_uri": "tk-config-basic", "force": True, "project_folder_name": "bootstrap_test", "project_id": self.project["id"], path_param: self.installed_config_location, } setup_project = sgtk.get_command("setup_project") setup_project.set_logger(logger) sgtk.set_authenticated_user(self.user) with patch( "tank.pipelineconfig_utils.resolve_all_os_paths_to_core", return_value=sgtk.util.ShotgunPath.from_current_os_path( install_location ).as_system_dict() ): setup_project.execute(params) # Find the project and pipeline configuration in Shotgun. project = self.sg.find_one("Project", [["id", "is", self.project["id"]]]) pc = self.sg.find_one("PipelineConfiguration", [["code", "is", "Primary"], ["project", "is", project]]) # Bootstrap into the tk-shell123 engine. manager = sgtk.bootstrap.ToolkitManager(self.user) manager.pipeline_configuration = pc["id"] try: engine = manager.bootstrap_engine("tk-shell123", project) except Exception as e: # note: due to core swapping this comparison needs to happen by name self.assertEqual(e.__class__.__name__, sgtk.platform.TankMissingEngineError.__name__) engine = manager.bootstrap_engine("tk-shell", project) self.assertEqual(engine.name, "tk-shell")
def start_engine(data): """ Start the tk-desktop engine given a data dictionary like the one passed to the launch_python hook. """ sys.path.append(data["core_python_path"]) # make sure we don't inherit the GUI's pipeline configuration os.environ["TANK_CURRENT_PC"] = data["config_path"] import sgtk sgtk.util.append_path_to_env_var("PYTHONPATH", data["core_python_path"]) # Initialize logging right away instead of waiting for the engine if we're using a 0.18 based-core. # This will also ensure that a crash will be tracked if hasattr(sgtk, "LogManager"): sgtk.LogManager().initialize_base_file_handler("tk-desktop") # If the core supports the shotgun_authentication module and the pickle has # a current user, we have to set the authenticated user. if hasattr(sgtk, "set_authenticated_user"): # Retrieve the currently authenticated user for this process. from tank_vendor.shotgun_authentication import ShotgunAuthenticator, deserialize_user current_user = ShotgunAuthenticator( sgtk.util.CoreDefaultsManager()).get_default_user() # If we found no user using the authenticator, we need to use the credentials that # came through the environment variable. # Also, if the credentials are user-based, we need to disregard what we got and use # the credentials from the environment variable. This is required to solve any issues # arising from the changes to the session cache changing place in core 0.18. if not current_user or current_user.login: current_user = deserialize_user( os.environ["SHOTGUN_DESKTOP_CURRENT_USER"]) else: # This happens when the user retrieved from the project's core is a script. # In that case, we use the script user and disregard who is the current # authenticated user at the site level. pass sgtk.set_authenticated_user(current_user) tk = sgtk.sgtk_from_path(data["config_path"]) tk._desktop_data = data["proxy_data"] ctx = tk.context_from_entity("Project", data["project"]["id"]) engine = sgtk.platform.start_engine("tk-desktop", tk, ctx) return engine
def main(): opts = parse_args() # import toolkit from the specified core install sys.path.insert(0, opts.core_python_path) import sgtk if hasattr(sgtk, "set_authenticated_user"): # import authentication from tank_vendor import shotgun_authentication # Initialize the authenticator with Toolkit's defaults manager. dm = sgtk.util.CoreDefaultsManager() sg_auth = shotgun_authentication.ShotgunAuthenticator(dm) # get the current user user = sg_auth.get_default_user() sgtk.set_authenticated_user(user) import sgtk.platform.engine # load up toolkit and get the environment for the project context tk = sgtk.sgtk_from_path(opts.configuration_path) ctx = tk.context_from_entity("Project", int(opts.project_id)) env = sgtk.platform.engine.get_environment_from_context(tk, ctx) # make a backup of the original yml file shutil.copy(env.disk_location, "%s.orig" % env.disk_location) # install the tk-desktop engine if it is not installed if "tk-desktop" not in env.get_engines(): install_cmd = tk.get_command("install_engine") params = { "environment": env.name, "engine_uri": "tk-desktop", } install_cmd.execute(params) # reload the new environment env = sgtk.platform.engine.get_environment_from_context(tk, ctx) # copy the apps from tk-shell copy_apps_cmd = tk.get_command("copy_apps") params = { "environment": env.name, "src_engine_instance": "tk-shell", "dst_engine_instance": "tk-desktop", } copy_apps_cmd.execute(params)
def __launch_app(app, splash, user, app_bootstrap, settings): """ Shows the splash screen, optionally downloads and configures Toolkit, imports it, optionally updates it and then launches the desktop engine. :param app: Application object for event processing. :param splash: Splash dialog to update user on what is currently going on :param user: Current ShotgunUser. :param app_bootstrap: Application bootstrap. :param settings: The application's settings. :returns: The error code to return to the shell. """ # show the splash screen splash.show() import sgtk sgtk.set_authenticated_user(user) # Downloads an upgrade for the startup if available. startup_updated = upgrade_startup( splash, sgtk, app_bootstrap ) if startup_updated: __restart_app_with_countdown(splash, "Shotgun Desktop updated.") splash.set_message("Looking up site configuration.") connection = user.create_sg_connection() _assert_toolkit_enabled(splash, connection) logger.debug("Getting the default site configuration.") pc_path, pc, toolkit_classic_required = shotgun_desktop.paths.get_pipeline_configuration_info(connection) # We're about to bootstrap, so remove sgtk from our scope so that if we add # code that uses it after the bootstrap we have to import the # new core. del sgtk if toolkit_classic_required: engine = __start_engine_in_toolkit_classic(app, splash, user, pc, pc_path) else: engine = __start_engine_in_zero_config(app, app_bootstrap, splash, user) return __post_bootstrap_engine(splash, app_bootstrap, engine, settings)
def tk_connect_bak(api_script, api_key, host): """ :param api_script: shotgun script name :param api_key: key :param host: host url :return: """ sa = sgtk.authentication.ShotgunAuthenticator() # Use the authenticator to create a user object. This object # identifies a Shotgun user or script and also wraps around # a Shotgun API instance which is associated with that user. user = sa.create_script_user(api_script=api_script, api_key=api_key, host=host) # tell the Toolkit Core API which user to use sgtk.set_authenticated_user(user)
def tk_connect(api_script, api_key): # Import Toolkit so we can access to Toolkit specific features. # Import the ShotgunAuthenticator from the tank_vendor.shotgun_authentication # module. This class allows you to authenticate either interactively or, in this # case, programmatically. from tank_vendor.shotgun_authentication import ShotgunAuthenticator # Instantiate the CoreDefaultsManager. This allows the ShotgunAuthenticator to # retrieve the site, proxy and optional script_user credentials from shotgun.yml cdm = sgtk.util.CoreDefaultsManager() # Instantiate the authenticator object, passing in the defaults manager. authenticator = ShotgunAuthenticator(cdm) # Create a user programmatically using the script"s key. user = authenticator.create_script_user(api_script, api_key) # print "User is "%s"" % user # Tells Toolkit which user to use for connecting to Shotgun. sgtk.set_authenticated_user(user)
def publish_preview(src_path): # src_path = 'D:/work/amg/projects/dev/sequences/EP001/SH001/Anim/work/maya/scene1.mb'.replace('/','\\') trg_path = 'D:/work/amg/projects/dev/sequences/EP001/SH001/Anim/work/maya/scene1.mb'.replace( '/', '\\') sa = ShotgunAuthenticator() user = sa.create_script_user(api_script="Toolkit", api_key="", host="https://animagrad.shotgunstudio.com") sgtk.set_authenticated_user(user) tk = sgtk.sgtk_from_path(trg_path) ctx = tk.context_from_path(trg_path) publish_name = os.path.splitext(os.path.basename(src_path))[0] # thumbnail_path = path (545x300) try: sgtk.util.register_publish(tk, ctx, src_path, publish_name, 3) return True except: return False
def __initialize_sgtk_authentication(sgtk, app_bootstrap): """ Sets the authenticated user if available. Also registers the authentication module's logger with the Desktop's. :param sgtk: The Toolkit API handle. :param app_bootstrap: The application bootstrap instance. """ # If the version of Toolkit supports the new authentication mechanism if __toolkit_supports_authentication_module(sgtk): # import authentication from tank_vendor import shotgun_authentication # Add the module to the log file. app_bootstrap.add_logger_to_logfile(shotgun_authentication.get_logger()) dm = sgtk.util.CoreDefaultsManager() sg_auth = shotgun_authentication.ShotgunAuthenticator(dm) # get the current user user = sg_auth.get_default_user() logger.info("Setting current user: %r" % user) sgtk.set_authenticated_user(user)
def __initialize_sgtk_authentication(sgtk, app_bootstrap): """ Sets the authenticated user if available. Also registers the authentication module's logger with the Desktop's. :param sgtk: The Toolkit API handle. :param app_bootstrap: The application bootstrap instance. """ # If the version of Toolkit supports the new authentication mechanism if __toolkit_supports_authentication_module(sgtk): # import authentication from tank_vendor import shotgun_authentication # Add the module to the log file. app_bootstrap.add_logger_to_logfile( shotgun_authentication.get_logger()) dm = sgtk.util.CoreDefaultsManager() sg_auth = shotgun_authentication.ShotgunAuthenticator(dm) # get the current user user = sg_auth.get_default_user() logger.info("Setting current user: %r" % user) sgtk.set_authenticated_user(user)
def tearDown(self): """ Cleans up after tests. """ sgtk.set_authenticated_user(self._authenticated_user) # get rid of path cache from local ~/.shotgun storage pc = path_cache.PathCache(self.tk) path_cache_file = pc._get_path_cache_location() pc.close() if os.path.exists(path_cache_file): os.remove(path_cache_file) # clear global shotgun accessor tank.util.shotgun._g_sg_cached_connections = threading.local() # get rid of init cache if os.path.exists(self.init_cache_location): os.remove(self.init_cache_location) # move project scaffold out of the way self._move_project_data() # important to delete this to free memory self.tk = None
def __launch_app(app, splash, user, app_bootstrap, settings): """ Shows the splash screen, optionally downloads and configures Toolkit, imports it, optionally updates it and then launches the desktop engine. :param app: Application object for event processing. :param splash: Splash dialog to update user on what is currently going on :param user: Current ShotgunUser. :param app_bootstrap: Application bootstrap. :param settings: The application's settings. :returns: The error code to return to the shell. """ # show the splash screen splash.show() import sgtk sgtk.set_authenticated_user(user) # Downloads an upgrade for the startup if available. startup_updated = upgrade_startup(splash, sgtk, app_bootstrap) if startup_updated: # We need to restore the global debug logging setting prior to # restarting the app so that forced debug logging is not remembered # as the startup state. Once Desktop relaunches it will resume forced # debug logging until core swap, when the original launch setting is # restored. __restore_global_debug_flag() __restart_app_with_countdown(splash, "Shotgun Desktop updated.") splash.set_message("Looking up site configuration.") connection = user.create_sg_connection() _assert_toolkit_enabled(splash, connection) logger.debug("Getting the default site configuration.") pc_path, pc, toolkit_classic_required = shotgun_desktop.paths.get_pipeline_configuration_info( connection) # We need to toggle the global debug logging setting back prior to swapping # core. Cores older than v0.18.117 do not manage the TK_DEBUG environment # variable when global debug is toggled, so we can end up in a situation # where the new core in desktopstartup toggles it on, setting the env var, # and then when the toggle off occurs we end up with the older core in the # site config NOT purging the TK_DEBUG env var. The result is that any # subprocesses spawned then end up with debug logging on when the user # didn't ask for it. This impacts engine command execution from both Desktop # and via browser integration. It is the biggest issue with browser # integration, however, as the debug logs are reported back to the web # app from the desktopserver RPC API, and the user is presented with a # dialog full of debug log messages. __restore_global_debug_flag() # We're about to bootstrap, so remove sgtk from our scope so that if we add # code that uses it after the bootstrap we have to import the # new core. del sgtk if toolkit_classic_required: engine = __start_engine_in_toolkit_classic(app, splash, user, pc, pc_path) else: engine = __start_engine_in_zero_config(app, app_bootstrap, splash, user) return __post_bootstrap_engine(splash, app_bootstrap, engine, settings)
def __launch_app(app, splash, user, app_bootstrap, settings): """ Shows the splash screen, optionally downloads and configures Toolkit, imports it, optionally updates it and then launches the desktop engine. :param app: Application object for event processing. :param splash: Splash dialog to update user on what is currently going on :param user: Current ShotgunUser. :param app_bootstrap: Application bootstrap. :param settings: The application's settings. :returns: The error code to return to the shell. """ # show the splash screen splash.show() import sgtk sgtk.set_authenticated_user(user) # Downloads an upgrade for the startup if available. startup_updated = upgrade_startup( splash, sgtk, app_bootstrap ) if startup_updated: __restart_app_with_countdown(splash, "Shotgun Desktop updated.") splash.set_message("Looking up site configuration.") connection = user.create_sg_connection() _assert_toolkit_enabled(splash, connection) logger.debug("Getting the default site configuration.") pc_path, pc, toolkit_classic_required = shotgun_desktop.paths.get_pipeline_configuration_info(connection) # We need to toggle the global debug logging setting back prior to swapping # core. Cores older than v0.18.117 do not manage the TK_DEBUG environment # variable when global debug is toggled, so we can end up in a situation # where the new core in desktopstartup toggles it on, setting the env var, # and then when the toggle off occurs we end up with the older core in the # site config NOT purging the TK_DEBUG env var. The result is that any # subprocesses spawned then end up with debug logging on when the user # didn't ask for it. This impacts engine command execution from both Desktop # and via browser integration. It is the biggest issue with browser # integration, however, as the debug logs are reported back to the web # app from the desktopserver RPC API, and the user is presented with a # dialog full of debug log messages. __restore_global_debug_flag() # We're about to bootstrap, so remove sgtk from our scope so that if we add # code that uses it after the bootstrap we have to import the # new core. del sgtk if toolkit_classic_required: engine = __start_engine_in_toolkit_classic(app, splash, user, pc, pc_path) else: engine = __start_engine_in_zero_config(app, app_bootstrap, splash, user) return __post_bootstrap_engine(splash, app_bootstrap, engine, settings)
def main(): from python.create_client import CreateClient, ensure_create_server_is_running user = sgtk.authentication.ShotgunAuthenticator().get_default_user() if not user: print("Unable to create a Desktop Client unauthenticated.") return 1 sgtk.set_authenticated_user(user) if not ensure_create_server_is_running(user.create_sg_connection()): print("Failed to ensure that Shotgun Create is running") return 2 client = CreateClient(user.create_sg_connection()) commands = client.call_server_method("list_supported_commands") print("CreateClient standalone client") print() print("Usage:") print("> COMMAND :: ARGUMENT") print() print() print("Example:") print('> sgc_open_task_board :: { "project_id" : null }') print() print() print("Available commands:") for command in sorted(commands): print(" - " + str(command)) print() while True: try: print("Enter command ('exit' to exit )") try: user_input = raw_input("> ").strip() except NameError: user_input = input("> ").strip if not user_input: continue if user_input == "exit": return 0 if "::" in user_input: command, args = user_input.split("::") command = str(command.strip()) args = str(args.strip()) else: command = user_input.strip() args = "{}" print() print("Command: {0}".format(command)) print("Arguments: {0}".format(args)) print() server_resp = client.call_server_method(command, json.loads(args)) print(json.dumps(server_resp, indent=2, sort_keys=True)) print() except RuntimeError as e: print(str(e)) pass
def start_engine(self): engine = None try: import tank except Exception as e: print("ERROR: Failed to import tank.\n", file=sys.stderr) return engine # Defaults to tk-rv if no other engine name found in environment. engine_name = os.environ.get("TANK_ENGINE", "tk-rv") if os.environ.get("TANK_CONTEXT"): try: context = tank.context.deserialize( os.environ.get("TANK_CONTEXT")) except Exception as e: err = traceback.format_exc() print( "WARNING: Could not create context! Tank will be disabled: {0}" .format(traceback.format_exc()), file=sys.stderr, ) return engine else: import sgtk # if you want to force a Toolkit-style login, here's how: # # import tank_vendor.shotgun_authentication # sa = tank_vendor.shotgun_authentication.ShotgunAuthenticator() # sa.get_user_from_prompt() # user = sa.get_user() try: import slutils_py # Get default session info from slutils (rv/shotgun licensing) module (url, login, token) = slutils_py.defaultSession() user = ShotgunUser( RVUserImpl(url, login, token, ShotgunToolkit.http_proxy_from_env_vars())) sg_conn = user.create_sg_connection() sgtk.set_authenticated_user(user) # XXX what if previous session is not the server we want ? # XXX this forces restart if we fail here. we instead should # wait for login process to succeed and then continue. except: err = traceback.print_exc() commands.alertPanel( True, commands.ErrorAlert, "Login Session Invalid", "Login with RV Shotgun session token failed; please use the File Menu's " '"License Manager" to log in to the Shotgun server and re-start RV.', "Continue", None, None, ) return None projectName = "Big Buck Bunny" if os.environ.get("TANK_PROJECT_NAME"): projectName = os.environ.get("TANK_PROJECT_NAME") print("DEBUG: find project '%s'.\n" % projectName, file=sys.stderr) project = sg_conn.find("Project", [["name", "is", projectName]]) print("DEBUG: find result '%s'.\n" % str(project), file=sys.stderr) tk = sgtk.sgtk_from_entity(project[0]["type"], project[0]["id"]) context = tk.context_from_entity_dictionary(project[0]) try: print("INFO: Starting TK-RV Engine", sys.stderr) engine = tank.platform.start_engine(engine_name, context.tank, context) except Exception as e: print( "WARNING: Could not start engine: " "{0}".format(traceback.format_exc()), file=sys.stderr, ) return engine # clean up temp env vars for var in ["TANK_ENGINE", "TANK_CONTEXT", "TANK_FILE_TO_OPEN"]: if var in os.environ: del os.environ[var] return engine
# create template Nuke scripts if they don't exist # add shots, sequences, and plates into the database if they don't already exist ihdb = DB.DBAccessGlobals.get_db_access() b_create_nuke = False import nuke tk = None # Shotgun Authentication sa = sgtk.authentication.ShotgunAuthenticator() user = sa.create_script_user(api_script='goosebumps2_api_access', api_key='a3a1d0ccd72ffdc073ff151dd52c84abe1a5dd6d4fe18fba1efa882df8b1e36a', host='https://qppe.shotgunstudio.com') sgtk.set_authenticated_user(user) for shot_dir in g_dict_img_seq.keys(): shot = None seq = None b_create_nuke = False matchobject = re.search(g_shot_regexp, shot_dir) # make sure this file matches the shot pattern if not matchobject: print "ERROR: somehow shot directory %s isn't actually a shot!"%shot_dir continue else: shot = matchobject.groupdict()['shot'] seq = matchobject.groupdict()['sequence'] print "INFO: Beginning Nuke script process for %s."%shot