def connect(self): sg = None if self.user_auth_method: try: if not self.__user_token: sg = shotgun_api3.Shotgun(self.__host, login=self.__user, password=self.__user_password) elif self.__user_token: sg = shotgun_api3.Shotgun(self.__host, login=self.__user, token=self.__user_token) else: raise RuntimeError( "You must provide a valid user authentication or script authentication." ) except Exception as e: raise RuntimeError( "Error while connect with Shotgun - {}".format(e)) elif self.script_auth_method: try: sg = shotgun_api3.Shotgun( self.__host, script_name=self.__script_name, api_key=self.__script_pass, ) except Exception as e: raise RuntimeError( "Error while connect with Shotgun - {}".format(e)) return sg
def test_http_proxy_server_and_port_with_authentication(self): proxy_server = "someserver.com" proxy_port = 1234 proxy_user = "******" proxy_pass = "******" http_proxy = "%s:%s@%s:%d" % (proxy_user, proxy_pass, proxy_server, proxy_port) sg = api.Shotgun(self.server_path, self.script_name, self.api_key, http_proxy=http_proxy, connect=False) self.assertEquals(sg.config.proxy_server, proxy_server) self.assertEquals(sg.config.proxy_port, proxy_port) self.assertEquals(sg.config.proxy_user, proxy_user) self.assertEquals(sg.config.proxy_pass, proxy_pass) proxy_server = "123.456.789.012" proxy_port = 1234 proxy_user = "******" proxy_pass = "******" http_proxy = "%s:%s@%s:%d" % (proxy_user, proxy_pass, proxy_server, proxy_port) sg = api.Shotgun(self.server_path, self.script_name, self.api_key, http_proxy=http_proxy, connect=False) self.assertEquals(sg.config.proxy_server, proxy_server) self.assertEquals(sg.config.proxy_port, proxy_port) self.assertEquals(sg.config.proxy_user, proxy_user) self.assertEquals(sg.config.proxy_pass, proxy_pass)
def setUp(self, auth_mode='ApiUser'): self.config = SgTestConfig() self.config.read_config(CONFIG_PATH) self.human_login = self.config.human_login self.human_password = self.config.human_password self.server_url = self.config.server_url self.script_name = self.config.script_name self.api_key = self.config.api_key self.http_proxy = self.config.http_proxy self.session_uuid = self.config.session_uuid if auth_mode == 'ApiUser': self.sg = api.Shotgun(self.config.server_url, self.config.script_name, self.config.api_key, http_proxy=self.config.http_proxy, connect=self.connect) elif auth_mode == 'HumanUser': self.sg = api.Shotgun(self.config.server_url, login=self.human_login, password=self.human_password, http_proxy=self.config.http_proxy, connect=self.connect) else: raise ValueError("Unknown value for auth_mode: %s" % auth_mode) if self.config.session_uuid: self.sg.set_session_uuid(self.config.session_uuid)
def test_bad_auth(self): '''test_bad_auth invalid script name or api key raises fault''' server_url = self.config.server_url script_name = 'not_real_script_name' api_key = self.config.api_key sg = shotgun_api3.Shotgun(server_url, script_name, api_key) self.assertRaises(shotgun_api3.Fault, sg.find_one, 'Shot', []) script_name = self.config.script_name api_key = 'notrealapikey' sg = shotgun_api3.Shotgun(server_url, script_name, api_key) self.assertRaises(shotgun_api3.Fault, sg.find_one, 'Shot', [])
def shotgun_api3_connect(*args, **kwargs): eps = [] for ep in pkg_resources.iter_entry_points('shotgun_api3_connect'): eps.append((ep, True)) for ep in pkg_resources.iter_entry_points('shotgun_api3_kwargs'): eps.append((ep, False)) eps.sort(key=lambda (ep, _): ep.name) for ep, is_direct in eps: func = ep.load() res = func(*args, **kwargs) if not res: continue if is_direct: return res import shotgun_api3 return shotgun_api3.Shotgun(**res) # Fall back onto the shotgun_api3_registry module. try: import shotgun_api3_registry as m except ImportError: pass else: return m.connect(*args, **kwargs) raise ValueError( "No shotgun_api3_connect/shotgun_api3_kwargs entry point or shotgun_api3_registry module found." )
def registerCallbacks(reg): """ Register our callbacks. :param reg: A Registrar instance provided by the event loop handler. """ # Grab an sg connection for the validator. sg = shotgun_api3.Shotgun(SERVER, script_name=SCRIPT_NAME, api_key=SCRIPT_KEY) # Bail if our validator fails. if not is_valid(sg, reg.logger): reg.logger.warning("Plugin is not valid, will not register callback.") return eventFilter = { "Shotgun_Version_Change": ["sg_uploaded_movie"], } # Temp solution for remote artist args = { "applied_group": "Remote Artists", } # Register our callback with the Shotgun_Version_Change event reg.registerCallback( SCRIPT_NAME, SCRIPT_KEY, download_submission, eventFilter, args, ) reg.logger.debug("Registered callback.")
def test_url(self): """Server url is parsed correctly""" login = self.human_user['login'] password = self.human_password self.assertRaises(ValueError, api.Shotgun, None, None, None, connect=False) self.assertRaises(ValueError, api.Shotgun, "file://foo.com", None, None, connect=False) self.assertEqual("/api3/json", self.sg.config.api_path) #support auth details in the url of the form login_password = "******" % (login, password) # login:password@domain auth_url = "%s%s@%s" % (self.uri_prefix, login_password, self.domain) sg = api.Shotgun(auth_url, None, None, connect=False) expected = "Basic " + base64.encodestring( urllib.unquote(login_password)).strip() self.assertEqual(expected, sg.config.authorization)
def registerCallbacks(reg): """ Register our callbacks. :param reg: A Registrar instance provided by the event loop handler. """ # Grab authentication env vars for this plugin. Install these into the env # if they don't already exist. server = os.environ["SG_SERVER"] script_name = os.environ["SGDAEMON_ASSIGNTOPROJECT_NAME"] script_key = os.environ["SGDAEMON_ASSIGNTOPROJECT_KEY"] # Grab an sg connection for the validator. sg = shotgun_api3.Shotgun(server, script_name=script_name, api_key=script_key) # Bail if our validator fails. if not is_valid(sg, reg.logger): reg.logger.warning("Plugin is not valid, will not register callback.") return # Register our callback with the Shotgun_%s_Change event and tell the logger # about it. reg.registerCallback( script_name, script_key, chief_cmt, {"Shotgun_Note_Change": "user" }, #, ['user', 'is', {'type':'HumanUser', 'id':'yizeon' }] None, ) reg.logger.debug("Registered callback.")
def _connect_to_sg(self): """ Adds sg handles to the self._sites dict and removes credentials. """ # Grab a Python API handle for each Shotgun Site and add it to the # self._sites dict. for site_url, credentials in self._sites.iteritems(): if not credentials.get("script_name") or not credentials.get( "script_key"): raise ValueError( "Bad or missing settings for %s in settings.yml, exiting." % site_url) logging.info("Connecting to %s..." % site_url) credentials["sg"] = shotgun_api3.Shotgun( site_url, script_name=credentials["script_name"], api_key=credentials["script_key"], ) # We don't need these anymore, so lets clear them out of memory. credentials.pop("script_name", None) credentials.pop("script_key", None)
def __init__(self, configPath): """ """ self._continue = True self._eventIdData = {} # Read/parse the config config = ConfigParser.ConfigParser() config.read(configPath) # Get config values self._logFactory = self._logFactory = LogFactory(config) self._log = self._logFactory.getLogger('engine', emails=True) self._pluginCollections = [ PluginCollection(self, s.strip()) for s in config.get('plugins', 'paths').split(',') ] self._server = config.get('shotgun', 'server') self._sg = sg.Shotgun(self._server, config.get('shotgun', 'name'), config.get('shotgun', 'key')) self._eventIdFile = config.get('daemon', 'eventIdFile') self._max_conn_retries = config.getint('daemon', 'max_conn_retries') self._conn_retry_sleep = config.getint('daemon', 'conn_retry_sleep') self._fetch_interval = config.getint('daemon', 'fetch_interval') self._use_session_uuid = config.getboolean('shotgun', 'use_session_uuid') super(Engine, self).__init__('shotgunEvent', config.get('daemon', 'pidFile'))
def process(id, name, conf): engine = EngineCli("shotgunEventDaemon.conf") # Get The EventLogEntry ID print(engine.config.getShotgunURL()) print(engine.config.getEngineScriptName()) print(engine.config.getEngineScriptKey()) sgConnection = sg.Shotgun(engine.config.getShotgunURL(), engine.config.getEngineScriptName(), engine.config.getEngineScriptKey()) event = sgConnection.find_one("EventLogEntry", [["id", "is", int(id)]], fields=[ 'id', 'event_type', 'attribute_name', 'meta', 'entity', 'user', 'project', 'session_uuid', 'created_at' ]) # Initialise the plugin. plugcollections = [ sgED.PluginCollection(engine, s) for s in engine.config.getPluginPaths() ] for plugc in plugcollections: plugc.load() for plugc in plugcollections: plugc.process(event)
def registerCallbacks(reg): """ Register all necessary or appropriate callbacks for this plugin. """ file_object = open( r"//genesisnx/genesisnx/Animation/Shotgun/System/Tools/shotgun/create_project_directory.txt", "r") eventFilter = { "Shotgun_Project_Change": ["name", "sg_client", "sg_brand"], "Shotgun_Asset_Change": ["code"], "Shotgun_Shot_Change": ["code"] } server = "https://vaynerproductions.shotgunstudio.com" script_name = os.path.basename(__file__).split(".")[0] + ".py" script_key = file_object.readline() file_object.close() sg = shotgun_api3.Shotgun(server, script_name, script_key) reg.registerCallback( script_name, script_key, create_project_directory, eventFilter, None, ) reg.logger.debug("Registered callback.")
def createShotgunNote(PROJECT_ID,shotTable,sendTaskCombo): sg = shotgun.Shotgun(SERVER_PATH, SCRIPT_USER, SCRIPT_KEY) import getpass user=getpass.getuser() fields = ['id', 'name','login'] filters = [['login', 'is',user]] userReturn = sg.find_one('HumanUser',filters,fields) #get shot id, task id #get shot shotName=shotTable.selectedItems()[0].text() filters = [['project','is', {'type':'Project','id':PROJECT_ID}],['code', 'is',shotName]] shot = sg.find_one('Shot',filters) task=sendTaskCombo.currentText() filters = [ ['entity','is',{'type':'Shot','id':shot['id']}] , ['content','is', task]] taskID = sg.find_one('Task',filters) content=self.notesTextEdit.toPlainText() for line in content.split('\n'): # enter data here for a note to create data = {'subject':task+' Note','content':line,'user':userReturn,'project': {"type":"Project","id": PROJECT_ID},'note_links':[{'type': 'Shot', 'id': shot['id'], 'name':shotName}],'tasks': [{'type': 'Task', 'id': taskID['id'], 'name': task}]} # create the note noteID = sg.create('Note',data) self.notesTextEdit.setPlainText("") self.shotgunNotes,self.shotgunShotData=sgMethods.getShotgunData(PROJECT_ID) if task=='Composite': sg.update('Task', taskID['id'], {'sg_status_list': 'fkd'})
def resetCompStatus(PROJECT_ID,Sequences): sg = shotgun.Shotgun(SERVER_PATH, SCRIPT_USER, SCRIPT_KEY) task = nuke.ProgressTask('reseting shotgun comp status:') for sq in Sequences: fields = ['id', 'code', 'sg_status_list','shots'] filters = [['project','is', {'type':'Project','id':PROJECT_ID}],['code', 'is',sq]] seq = sg.find_one('Sequence',filters,fields) for shot in seq['shots']: fields = ['id', 'code', 'sg_status_list','open_notes'] filters = [['id', 'is',shot['id']],['sg_status_list', 'is_not','omt']] sh= sg.find_one('Shot',filters,fields) if sh: fields = ['id', 'code', 'sg_status_list'] filters = [ ['entity','is',{'type':'Shot','id':sh['id']}] , ['content','is', 'Composite' ],['sg_status_list', 'is_not','na'],['sg_status_list', 'is_not','wtg']] taskID = sg.find_one('Task',filters,fields) task.setMessage(sh['code']) if taskID: sg.update('Task', taskID['id'], {'sg_status_list': 'cmpt'}) #if notes, change to problem for n in sh['open_notes']: id= n['id'] fields = ['sg_status_list','tasks','name'] filters = [['id', 'is',id]] note = sg.find_one('Note',filters,fields) for t in note['tasks']: if 'Composite' in t['name']: fields = ['id', 'code', 'sg_status_list'] filters = [ ['entity','is',{'type':'Shot','id':sh['id']}] , ['content','is', 'Composite' ]] taskID = sg.find_one('Task',filters,fields) sg.update('Task', taskID['id'], {'sg_status_list': 'fkd'}) del(task)
def __init__(self, configPath): """ """ self._continue = True self._eventIdData = {} # Read/parse the config self.config = Config(configPath) # Get config values self._pluginCollections = [ PluginCollection(self, s) for s in self.config.getPluginPaths() ] print self.config.getShotgunURL() print self.config.getEngineScriptName() print self.config.getEngineScriptKey() print self.config.getEngineProxyServer() sg.shotgun.NO_SSL_VALIDATION = True self._sg = sg.Shotgun(self.config.getShotgunURL(), self.config.getEngineScriptName(), self.config.getEngineScriptKey(), http_proxy=self.config.getEngineProxyServer()) self._max_conn_retries = self.config.getint('daemon', 'max_conn_retries') self._conn_retry_sleep = self.config.getint('daemon', 'conn_retry_sleep') self._fetch_interval = self.config.getint('daemon', 'fetch_interval') self._use_session_uuid = self.config.getboolean( 'shotgun', 'use_session_uuid') # Setup the loggers for the main engine if self.config.getLogMode() == 0: # Set the root logger for file output. rootLogger = logging.getLogger() rootLogger.config = self.config _setFilePathOnLogger(rootLogger, self.config.getLogFile()) print self.config.getLogFile() # Set the engine logger for email output. self.log = logging.getLogger('engine') self.setEmailsOnLogger(self.log, True) else: # Set the engine logger for file and email output. self.log = logging.getLogger('engine') self.log.config = self.config _setFilePathOnLogger(self.log, self.config.getLogFile()) self.setEmailsOnLogger(self.log, True) self.log.setLevel(self.config.getLogLevel()) # Setup the timing log file timing_log_filename = self.config.getTimingLogFile() if timing_log_filename: self.timing_logger = logging.getLogger('timing') self.timing_logger.setLevel(self.config.getLogLevel()) _setFilePathOnLogger(self.timing_logger, timing_log_filename) else: self.timing_logger = None super(Engine, self).__init__()
def __init__(self, hostname: str, login: str, password: str): self.hostname = hostname self.login = login self.password = password self.sg = shotgun_api3.Shotgun(self.hostname, login=self.login, password=self.password)
def registerCallback( self, sgScriptName, sgScriptKey, callback, matchEvents=None, args=None, stopOnError=True, ): """ Register a callback in the plugin. """ global sg sgConnection = sg.Shotgun( self._engine.config.getShotgunURL(), sgScriptName, sgScriptKey, http_proxy=self._engine.config.getEngineProxyServer(), ) self._callbacks.append( Callback( callback, self, self._engine, sgConnection, matchEvents, args, stopOnError, ))
def registerCallback(self, sgScriptName, sgScriptKey, callback, matchEvents=None, args=None): """ Register a callback in the plugin. """ global sg sgConnection = sg.Shotgun(self._engine.config.getShotgunURL(), sgScriptName, sgScriptKey) self._callbacks.append(Callback(callback, self, self._engine, sgConnection, matchEvents, args))
def execute(self): import shotgun_api3 apihandle = shotgun_api3.Shotgun(self.host.value(), script_name=self.apiScript.value(), api_key=self.apiKey.value(), connect=False) self.output.setValue(apihandle)
def _getShotgunConnection(): try: #### Get Shotgun Connection and Context when in SGTK session # get the engine we are currently running in current_engine = sgtk.platform.current_engine() # get hold of the shotgun api instance used by the engine, (or we could have created a new one) sg = current_engine.shotgun return sg except: #### Get Shotgun Connection and Context when not in SGTK session (example: farm) ##################################################### logBig("Importing Shotgun API3") ##################################################### shotgun_api3_location = os.environ["SHOTGUN_API3"] sys.path.append(shotgun_api3_location) import shotgun_api3 log("Imported the Shotgun Standalone API3") ##################################################### logBig("Connecting to Shotgun API") ##################################################### sg = shotgun_api3.Shotgun(os.environ["SHOTGUN_API_SERVER_PATH"], os.environ["SHOTGUN_API_SCRIPT_NAME"], os.environ["SHOTGUN_API_SCRIPT_KEY"]) log("Connected to Shotgun!") return sg
def getShotgunTaskData(scriptShot): import shotgun_api3 as shotgun SERVER_PATH = "https://psyop.shotgunstudio.com" SCRIPT_USER = "******" SCRIPT_KEY = "e0078c0e80f09ee7a76de2c25afce6bd34a5bc601f598d446daf6a8e848d9089" PROJECT_ID = 1674 sg = shotgun.Shotgun(SERVER_PATH, SCRIPT_USER, SCRIPT_KEY) filters = [['project', 'is', { 'type': 'Project', 'id': PROJECT_ID }], ['code', 'is', scriptShot]] shot = sg.find_one('Shot', filters) fields = [ 'id', 'entity', 'code', 'sg_status_list', 'task_assignees', 'content', 'tasks' ] filters = [['project', 'is', { "type": 'Project', 'id': PROJECT_ID }], ['entity', 'is', { "type": 'Shot', 'id': shot['id'] }]] tasks = sg.find('Task', filters, fields) taskDict = {} for t in tasks: taskDict[t['content']] = t['task_assignees'][0]['name'] return taskDict
class LocalDBEventSpooler(object): """ Continuously spools events from couchdb and transfers them to shotgun """ src = None # local database connector cur = None sg = None def _connect(self): """ establish the connections establish a connection to local server and shotgun """ try: self.src = connectors.DatabaseModificator() except Exception, error: #IGNORE:W0703 debug.error("Unable to _connect to database server. " + unicode(error)) return False try: self.sg = shotgun_api3.Shotgun(config.SHOTGUN_URL, config.SHOTGUN_SYNC_SKRIPT, config.SHOTGUN_SYNC_KEY) except Exception, error: #IGNORE:W0703 debug.error("Unable to _connect to Shotgun server. " + unicode(error)) return False
def registerCallbacks(reg): """ Register our callbacks. :param reg: A Registrar instance provided by the event loop handler. """ # Grab authentication env vars for this plugin. Install these into the env # if they don't already exist. server = os.environ["SG_SERVER"] script_name = os.environ["SG_SCRIPT_NAME"] script_key = os.environ["SG_SCRIPT_KEY"] # Grab an sg connection for the validator. sg = shotgun_api3.Shotgun(server, script_name=script_name, api_key=script_key) # Bail if our validator fails. if not is_valid(sg, reg.logger): reg.logger.warning("Plugin is not valid, will not register callback.") return eventFilter = {"Shotgun_Task_Change": "task_assignees"} reg.registerCallback( script_name, script_key, task_assignment_alert, eventFilter, None, ) reg.logger.debug("Registered callback.")
def registerCallbacks(reg): """ Register our callbacks :param reg: A Registrar instance provided by the event loop handler """ # Grab authentication env vars for this plugin. Install these into the env # if they don't already exist. server = os.environ["SG_SERVER"] script_name = os.environ["SGDAEMON_CNFVF_NAME"] script_key = os.environ["SGDAEMON_CNFVF_KEY"] args = { "sg_note_type": "Client", "content_field": "description", "author_is_artist": True, } # Grab an sg connection for the validator. sg = shotgun_api3.Shotgun(server, script_name=script_name, api_key=script_key) # Bail if our validator fails. if not is_valid(sg, reg.logger, args): reg.logger.warning("Plugin is not valid, will not register callback.") return reg.registerCallback( script_name, script_key, version_content_changed, {"Shotgun_Version_Change": args["content_field"]}, args, )
def registerCallbacks(reg): """ Register our callbacks. :param reg: A Registrar instance provided by the event loop handler. """ # Grab authentication env vars for this plugin. Install these into the env # if they don't already exist. server = os.environ["SG_SERVER"] script_name = os.environ["SG_SCRIPT_NAME"] script_key = os.environ["SG_SCRIPT_KEY"] # Grab an sg connection for the validator. sg = shotgun_api3.Shotgun(server, script_name=script_name, api_key=script_key) # Bail if our validator fails. if not is_valid(sg, reg.logger): reg.logger.warning("Plugin is not valid, will not register callback.") return # Register our callback with the Shotgun_%s_Change event and tell the logger # about it. reg.registerCallback( script_name, script_key, createChannel, {"Shotgun_Project_New": None}, None, ) reg.logger.debug("Registered callback.")
def connect(name=None, server=None, *args, **kwargs): server = _conform_server(server) if server == 'mock': from sgmock import Shotgun sg = Shotgun() if 'SGMOCK_FIXTURE' in os.environ: fixture = os.environ['SGMOCK_FIXTURE'] if ':' in fixture: module_name, func_name = fixture.split(':') else: module_name = 'sgmock.fixture.setup' func_name = fixture module = __import__(module_name, fromlist=['.']) func = getattr(module, func_name) func(sg) return sg kwargs = get_kwargs(name, server, *args, **kwargs) kwargs.setdefault('connect', False) return shotgun_api3.Shotgun(**kwargs)
def getShotgunPublishes(self, *args): import tank import shotgun_api3 as shotgun PROJECT_ID = tank.platform.current_engine().context.project['id'] SERVER_PATH = "https://psyop.shotgunstudio.com" SCRIPT_USER = "******" SCRIPT_KEY = "e0078c0e80f09ee7a76de2c25afce6bd34a5bc601f598d446daf6a8e848d9089" sg = shotgun.Shotgun(SERVER_PATH, SCRIPT_USER, SCRIPT_KEY) # Get handle to Asset Manager tank application assetmgr = tank.platform.current_engine().apps["tk-multi-assetmanager"] # Grab updated publish data from shotgun publish_directory = assetmgr.publish_directory publish_directory.update(async=False) # list image/lighting render publishes paths = [] for publish in list(publish_directory.all_publishes): if publish.component_type == 'image/lighting' and 'sequences' in publish.path: meta = [] for key in publish.metadata['aovs']: meta.append(publish.metadata['aovs'][key].replace( "\\", "/")) aovs = publish.metadata['aovs'] path = publish.path.replace("\\", "/") parts = path.split("/") newPath = "/".join( [parts[4], parts[6], parts[10], parts[11], parts[-1]]) verPath = "/".join([parts[4], parts[6], parts[10], parts[11]]) paths.append(newPath) self.publishData[verPath] = meta self.publishItems = paths
def registerCallbacks(reg): """ Register our callbacks :param reg: A Registrar instance provided by the event loop handler """ # Grab authentication env vars for this plugin. Install these into the env # if they don't already exist. server = os.environ["SG_SERVER"] script_name = os.environ["SGDAEMON_TSUVS_NAME"] script_key = os.environ["SGDAEMON_TSUVS_KEY"] # User-defined plugin args, change at will. args = {"status_mapping_field": "sg_version_status_mapping"} # Grab an sg connection for the validator. sg = shotgun_api3.Shotgun(server, script_name=script_name, api_key=script_key) # Bail if our validator fails. if not is_valid(sg, reg.logger, args): reg.logger.warning("Plugin is not valid, will not register callback.") return reg.registerCallback( script_name, script_key, task_status_changed, {"Shotgun_Task_Change": ["sg_status_list"]}, args, ) reg.logger.debug("Registered callback.")
def __init__(self, base_url, script_name=None, *args, **kwargs): """ Instantiate a :class:`shotgun_api3.shotgun.Shotgun` with the sanitized parameters. """ # Note: we use composition rather than inheritance to wrap the Shotgun # instance. Otherwise we would have to redefine all the methods we need # to wrap with some very similar code which would encode all params, # blindly call the original method, decode and return the result. safe_args = unicode_to_utf8(args) safe_kwargs = unicode_to_utf8(kwargs) self._shotgun = shotgun_api3.Shotgun( unicode_to_utf8(base_url), unicode_to_utf8(script_name), *safe_args, **safe_kwargs ) self._shotgun_schemas = {} # Retrieve our current login, this does not seem to be available from # the connection? self._shotgun_user = self.find_one( "ApiUser", [["firstname", "is", script_name]], ["firstname"] ) logger.info("Connected to %s." % base_url)
def registerCallbacks(reg): """ Register our callbacks. :param reg: A Registrar instance provided by the event loop handler. """ # Grab authentication env vars for this plugin. Install these into the env # if they don't already exist. server = os.environ["SG_SERVER"] script_name = os.environ["SGDAEMON_DATESTAMP_NAME"] script_key = os.environ["SGDAEMON_DATESTAMP_KEY"] # User-defined plugin args, change at will. args = { "entity_types": ["Shot"], "status_field": "sg_status_list", "statuses": ["fin"], "date_field": "sg_finaled_on", "timezone": "US/Pacific", "allow_date_overwrite": False, "set_date_on_entity_creation": False, } # Grab an sg connection for the validator. sg = shotgun_api3.Shotgun(server, script_name=script_name, api_key=script_key) # Bail if our validator fails. if not is_valid(sg, reg.logger, args): reg.logger.warning("Plugin is not valid, will not register callback.") return # Build our event_filter. event_filter = {} for entity_type in args["entity_types"]: # If both status_field and statuses are non-empty, add an entity Change # event to the match_events dict. if args["status_field"] and args["statuses"]: event_filter["Shotgun_%s_Change" % entity_type] = [args["status_field"]] # If set_date_on_entity_creation is true, add an entity New event to the # match_events dict. if args["set_date_on_entity_creation"]: event_filter["Shotgun_%s_New" % entity_type] = None # Register our callback with the Shotgun_%s_Change event and tell the logger # about it. reg.registerCallback( script_name, script_key, set_datestamp, event_filter, args, ) reg.logger.debug("Registered callback.")