def doesAssetAlreadyExistInScene(self, assetName): debug(app = self, method = 'doesAssetAlreadyExistInScene', message = 'assetName...\n%s' % assetName, verbose = False) assetExists = False for each in cmds.ls(type = 'transform'): if assetName in each: assetExists = True return assetExists
def get_default(self, name, default, force=False): # Temporary name fix for when we're given a setting name with the prefix # In the future, this test will be gone and no setting will have # the 'lldb.' prefix if not name.startswith(self.__prefix): # Final code should be: name = self.__prefix + name else: debug(debugAny, 'Setting name has lldb prefix: %s' % name) import traceback traceback.print_stack() if not force and name in self.__values: return self.__values[name] setting = default if sublime.active_window() and sublime.active_window().active_view(): setting = sublime.active_window().active_view().settings().get(name, default) if setting is default: setting = self.__settings.get(name, default) # Cache the setting value and setup a listener self.__values[name] = setting if name not in self.__settings_keys: self.__settings_keys.append(name) listener = self.create_listener(name) self.__settings.add_on_change(name, listener.on_change) debug(debugSettings, 'setting %s: %s' % (name, repr(setting))) return setting
def get_haar_points(self, haarCascade, method=co.cv.CV_HAAR_DO_CANNY_PRUNING): """ Search for points matching the haarcascade selected. Arguments: - self: The main object pointer. - haarCascade: The selected cascade. - methode: The search method to use. DEFAULT: co.cv.CV_HAAR_DO_CANNY_PRUNING. Returns a list with the matches. """ cascade = co.cv.cvLoadHaarClassifierCascade( haarCascade, self.imgSize ) if not cascade: debug.exception( "ocvfw", "The Haar Classifier Cascade load failed" ) co.cv.cvResize( self.img, self.small_img, co.cv.CV_INTER_LINEAR ) co.cv.cvClearMemStorage( self.storage ) points = co.cv.cvHaarDetectObjects( self.small_img, cascade, self.storage, 1.2, 2, method, co.cv.cvSize(20, 20) ) if points: matches = [ [ co.cv.cvPoint( int(r.x*self.imageScale), int(r.y*self.imageScale)), \ co.cv.cvPoint( int((r.x+r.width)*self.imageScale), int((r.y+r.height)*self.imageScale) )] \ for r in points] debug.debug( "ocvfw", "cmGetHaarPoints: detected some matches" ) return matches
def getUserFilmVotes(self, filmwebID, userData): self.userData = userData if self.login() == False: return False # pobranie oceny debug.debug('Zalogowano') vote_array = {} api_method = 'getUserFilmVotes [null, null]\n'.encode('string_escape') string = self.sendRequest(api_method, 'get') matches = re.findall('\[([0-9]+),[^,]+,([0-9]+),', string) if len(matches) > 0: for m in matches: vote_array[m[0]] = m[1] # pobranie tytułu api_method = 'getFilmsInfoShort [[' + filmwebID + ']]\n'.encode('string_escape') string = self.sendRequest(api_method, 'get') matches = re.findall('\[\["([^"]+)",', string) if len(matches) > 0: title = matches[0] else: title = '' if filmwebID in vote_array.keys(): return [title, vote_array[filmwebID]] else: return [title, '0']
def get_haar_roi_points(self, haarCascade, rect, origSize=(0, 0), method=co.cv.CV_HAAR_DO_CANNY_PRUNING): """ Search for points matching the haarcascade selected. Arguments: - self: The main object pointer. - haarCascade: The selected cascade. - methode: The search method to use. DEFAULT: co.cv.CV_HAAR_DO_CANNY_PRUNING. Returns a list with the matches. """ cascade = co.cv.cvLoadHaarClassifierCascade( haarCascade, self.imgSize ) if not cascade: debug.exception( "ocvfw", "The Haar Classifier Cascade load failed" ) co.cv.cvClearMemStorage(self.storage) imageROI = co.cv.cvGetSubRect(self.img, rect) if cascade: points = co.cv.cvHaarDetectObjects( imageROI, cascade, self.storage, 1.2, 2, method, co.cv.cvSize(20,20) ) else: debug.exception( "ocvfw", "The Haar Classifier Cascade load Failed (ROI)" ) if points: matches = [ [ co.cv.cvPoint( int(r.x+origSize[0]), int(r.y+origSize[1])), \ co.cv.cvPoint( int(r.x+r.width+origSize[0]), int(r.y+r.height+origSize[1] ))] \ for r in points] debug.debug( "ocvfw", "cmGetHaarROIPoints: detected some matches" ) return matches
def get(self): """Internal use only: not a public interface""" attempts = 2 result = "" if self.port is not None: while 1: c = self.port.read(1) # if nothing was recieved if len(c) == 0: if(attempts <= 0): break debug("get() found nothing") attempts -= 1 continue # skip carraige returns if c == '\r': continue # end on chevron if c == ">": break; else: # whatever is left must be part of the response result = result + c else: debug("NO self.port!", True) return result
def set_lkpoint(self, point): """ Set a point to follow it using the L. Kallman method. Arguments: - self: The main object pointer. - point: A co.cv.cvPoint Point. """ cvPoint = co.cv.cvPoint( point.x, point.y ) self.img_lkpoints["current"] = [ co.cv.cvPointTo32f ( cvPoint ) ] if self.img_lkpoints["current"]: co.cv.cvFindCornerSubPix ( self.grey, self.img_lkpoints["current"], co.cv.cvSize (20, 20), co.cv.cvSize (-1, -1), co.cv.cvTermCriteria (co.cv.CV_TERMCRIT_ITER | co.cv.CV_TERMCRIT_EPS, 20, 0.03)) point.set_opencv( cvPoint ) self.img_lkpoints["points"].append(point) setattr(point.parent, point.label, point) if len(self.img_lkpoints["last"]) > 0: self.img_lkpoints["last"].append( self.img_lkpoints["current"][0] ) debug.debug( "ocvfw", "cmSetLKPoints: New LK Point Added" ) else: self.img_lkpoints["current"] = []
def maintainMembers(): """ use the membersrefresh operation to maintain the universe of known nodes. """ global universe debug("Running maintain members.", info=True, threshold=1) possibledead = set(universe.keys()) membership.membersRefresh() # Add in new nodes. tempUniverse = membership.getCurrentMemberDict() for uid in tempUniverse: if uid not in universe and not me.getMe().__eq__(tempUniverse[uid]): universe[uid] = nodes.ExternalNode.fromBase(tempUniverse[uid]) if uid in possibledead: possibledead.remove(uid) # Remove dead nodes for dead in possibledead: deadNode(dead) # should I add me in here? not sure. universe[me.getMe().getUid()] = me.getMe() debug("has a universe of size: " + str(len(universe)), info=True)
def _publish_gpu_for_item(self, item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb): """ Export a gpu cache for the specified item and publish it to Shotgun. """ group_name = item["name"].strip("|") debug(app = None, method = '_publish_gpu_for_item', message = 'group_name: %s' % group_name, verbose = False) tank_type = output["tank_type"] publish_template = output["publish_template"] # get the current scene path and extract fields from it using the work template: scene_path = os.path.abspath(cmds.file(query=True, sn= True)) fields = work_template.get_fields(scene_path) publish_version = fields["version"] # update fields with the group name: fields["grp_name"] = group_name ## create the publish path by applying the fields with the publish template: publish_path = publish_template.apply_fields(fields) #'@asset_root/publish/gpu/{name}[_{grp_name}].v{version}.abc' gpuFileName = os.path.splitext(publish_path)[0].split('\\')[-1] fileDir = '/'.join(publish_path.split('\\')[0:-1]) debug(app = None, method = '_publish_gpu_for_item', message = 'gpuFileName: %s' % gpuFileName, verbose = False) ## Now fix the shaders shd.fixDGForGPU() if cmds.objExists('CORE_ARCHIVES_hrc'): cmds.setAttr('CORE_ARCHIVES_hrc.visiblity', 0) if cmds.objExists('ROOT_ARCHIVES_DNT_hrc'): cmds.setAttr('ROOT_ARCHIVES_DNT_hrc.visiblity', 0) ## build and execute the gpu cache export command for this item: try: print '=====================' print 'Exporting gpu now to %s\%s' % (fileDir, gpuFileName) #PUT THE FILE EXPORT COMMAND HERE cmds.select(clear = True) for geo in cmds.listRelatives(group_name, children = True): if 'geo_hrc' in geo: geoGroup = str(group_name) debug(app = None, method = '_publish_gpu_for_item', message = 'geoGroup: %s' % geoGroup, verbose = False) cmds.select(geoGroup) debug(app = None, method = '_publish_gpu_for_item', message = 'geoGroup: %s' % geoGroup, verbose = False) debug(app = None, method = '_publish_gpu_for_item', message = "gpuCache -startTime 1 -endTime 1 -optimize -optimizationThreshold 40000 -directory \"%s\" -fileName %s %s;" % (fileDir, gpuFileName, geoGroup), verbose = False) mel.eval("gpuCache -startTime 1 -endTime 1 -optimize -optimizationThreshold 40000 -directory \"%s\" -fileName %s %s;" % (fileDir, gpuFileName, geoGroup)) print 'Finished gpu export...' print '=====================' if cmds.objExists('dgSHD'): ## Now reconnect the FileIn nodes for key, var in filesDict.items(): cmds.connectAttr('%s.outColor' % key, '%s.color' % var) except Exception, e: raise TankError("Failed to export gpu cache file")
def setSpeakLanguage( nNumLang = getDefaultSpeakLanguage(), proxyTts = False ): "change the tts speak language" print( "SetSpeakLanguage to: %d" % nNumLang ); if( not proxyTts ): proxyTts = naoqitools.myGetProxy( "ALTextToSpeech" ); if( not proxyTts ): debug.debug( "ERR: setSpeakLanguage: can't connect to tts" ); return; try: if( nNumLang == constants.LANG_FR ): proxyTts.loadVoicePreference( "NaoOfficialVoiceFrench" ); elif ( nNumLang == constants.LANG_EN ): proxyTts.loadVoicePreference( "NaoOfficialVoiceEnglish" ); elif ( nNumLang == constants.LANG_SP ): proxyTts.loadVoicePreference( "NaoOfficialVoiceSpanish" ); elif ( nNumLang == constants.LANG_IT ): proxyTts.loadVoicePreference( "NaoOfficialVoiceItalian" ); elif ( nNumLang == constants.LANG_GE ): proxyTts.loadVoicePreference( "NaoOfficialVoiceGerman" ); elif ( nNumLang == constants.LANG_CH ): proxyTts.loadVoicePreference( "NaoOfficialVoiceChinese" ); elif ( nNumLang == constants.LANG_PO ): proxyTts.loadVoicePreference( "NaoOfficialVoicePolish" ); elif ( nNumLang == constants.LANG_KO ): proxyTts.loadVoicePreference( "NaoOfficialVoiceKorean" ); else: proxyTts.loadVoicePreference( "NaoOfficialVoiceEnglish" ); except: print( "ERR: setSpeakLanguage: loadVoicePreference error" );
def connectionLost(self, reason): """ Callback called when this connection is lost """ super.connectionLost() debug("Connection lost for reason: " + str(reason), info=True) _parentNode.destroyTCPConnection()
def onStateChange(self, uri, state, code, reason): debug("Call state: %s %s %s" % (uri, state, code)) self.uri = uri self.callerIDLabel.setText(self.uri) if state == "CALLING" or state == "CONNECTING": self.show_error(_("Calling...")) self.dialButton.hide() self.hangupButton.show() if state == "CONFIRMED": self.seconds = 0 self.callerIDLabel.setText(self.uri) self.timerLabel.setText(u"0:00") self.setWindowTitle(_("Call in process")) self.startTimer() self.show_call() if state == "DISCONNCTD": self.setWindowTitle(_("Telesk")) self.timerLabel.setText(u"0:00") if code == 503: self.show_error(_("Not available")) if code == 404: self.show_error(_("Not found")) if code == 486: self.show_error(_("Busy here")) if code == 603: self.show_error(_("Decline")) self.errortimer.start() self.connect(self.errortimer, QtCore.SIGNAL("timeout()"), self.show_dialer)
def _load_cache_data(self): cache = self.get_cache_path() debug(self, "Load: " + cache) if not os.path.exists(cache): return None mtime = None try: mtime = os.path.getmtime(cache) except: warn(self, "Cannot stat cache file: " + cache) refresh = self.get_cache_refresh() if refresh and refresh != -1: diff = time.time() - mtime if diff > refresh: debug(self, "Refreshing cache") self.hook_pre_refresh() return None data = None with open(cache, 'rb') as f: f = open(cache, 'rb') try: data = pickle.load(f) except: warn(self, "Picke can't load data from file") return None return data
def create(source, i, width, height, q): if (source[:5] == 'image'): output = '' jsonGet = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "Textures.GetTextures", "params": { "properties":["url", "cachedurl"], "filter": {"field": "url", "operator": "is", "value":"' + source + '"}}, "id": 1}') jsonGet = unicode(jsonGet, 'utf-8', errors='ignore') jsonGetResponse = json.loads(jsonGet) if 'result' in jsonGetResponse and 'textures' in jsonGetResponse['result']: for t in jsonGetResponse['result']['textures']: if 'cachedurl' in t and t['cachedurl'] != '': file = __thumbpath__ + t['cachedurl'].replace('\\', '/') # resize image try: image = Image.open(file) if image.mode != 'RGB': image = image.convert('RGB') h = image.size[1] if h > 10: if (h > height): image.load() image = image.resize((width, height), Image.ANTIALIAS) image_bin = cStringIO.StringIO() image.save(image_bin, 'JPEG', quality=int(q)) output = image_bin.getvalue() image_bin.close() except Exception as Error: debug.debug(str(file)) debug.debug(str(Error)) return output
def displayText(room,textlist,enqueue=False): #debug.warn("Displaying campaign text "+str(textlist)) if VS.isserver(): return if room==-1: debug.error("Room is -1!!!") import Base room=Base.GetCurRoom() func=Base.MessageToRoom if enqueue: func=Base.EnqueueMessageToRoom if type(textlist) is str: if textlist!='': debug.debug('*** Base.message('+textlist+')') func(room,textline(textlist)) else: if textlist and len(textlist): debug.debug('*** Base.message('+str(textlist[0])+')') #Base.MessageToRoom(room,str(textlist[0])) stri='' if enqueue: for x in textlist: func(room,textline(x)) else: for x in textlist: stri+=textline(x)+"\n" func(room,stri);
def untile(self): debug('Untiling %s' % (self)) for c in self.store.masters + self.store.slaves: c.restore() self.tiling = False xpybutil.conn.flush()
def doesAssetAlreadyExistInScene(self, assetName): debug(app = self, method = 'doesAssetAlreadyExistInScene', message = 'assetName...\n%s' % assetName, verbose = False) assetExists = False if cmds.ls(assetName) != []: assetExists = True return assetExists
def __init__(self, wid): self.wid = wid self.name = ewmh.get_wm_name(self.wid).reply() or 'N/A' debug('Connecting to %s' % self) window.listen(self.wid, 'PropertyChange', 'FocusChange') event.connect('PropertyNotify', self.wid, self.cb_property_notify) event.connect('FocusIn', self.wid, self.cb_focus_in) event.connect('FocusOut', self.wid, self.cb_focus_out) # This connects to the parent window (decorations) # We get all resize AND move events... might be too much self.parentid = window.get_parent_window(self.wid) window.listen(self.parentid, 'StructureNotify') event.connect('ConfigureNotify', self.parentid, self.cb_configure_notify) # A window should only be floating if that is default self.floating = config.floats_default # Not currently in a "moving" state self.moving = False # Load some data self.desk = ewmh.get_wm_desktop(self.wid).reply() # Add it to this desktop's tilers tile.update_client_add(self) # First cut at saving client geometry self.save()
def remove(self): tile.update_client_removal(self) debug('Disconnecting from %s' % self) event.disconnect('ConfigureNotify', self.parentid) event.disconnect('PropertyNotify', self.wid) event.disconnect('FocusIn', self.wid) event.disconnect('FocusOut', self.wid)
def __getitem__(self, key): if isinstance(key, int): return self.modes[key] elif isinstance(key, basestring): return self.__dict__[key] else: debug("OBD commands can only be retrieved by PID value or dict name", True)
def compute(self, _data): r = Response(_data) debug("command returned: %s" % _data) if "SEARCHING..." in _data: _data = _data[12:] # strips spaces, and removes [\n\r\t] _data = "".join(_data.split()) if (len(_data) > 0) and ("NODATA" not in _data) and isHex(_data): # the first 4 chars are codes from the ELM (we don't need those) _data = _data[4:] # constrain number of bytes in response if (self.bytes > 0): # zero bytes means flexible response constrainHex(_data, self.bytes) # decoded value into the response object r.set(self.decode(_data)) else: # not a parseable response debug("return data could not be decoded") return r
def ForEachSys (functio): debug.debug("Getting reachable systems...") systems = AllSystems() debug.debug("done") for sys in systems: functio(sys) return len(systems)
def get( self, strPathBoxName ): try: nNbrFrame = self.animations_FrameNumber[strPathBoxName]; except: nNbrFrame = 0; debug.debug( "INF: choregraphetools.FrameNumber.get( '%s' ): %d" % ( strPathBoxName, nNbrFrame ) ); return nNbrFrame;
def _setBaseFluidAttrs(fluid): #set required attributes attrs = ['ty', 'sx', 'sy', 'sz'] ## Lock attrs for eachAttr in attrs: cmds.setAttr ("%s.%s" % (fluid[0], eachAttr), lock = True) cmds.setAttr ("%s.%s" % (fluid[0], eachAttr), keyable = False , channelBox = False) #scale fluid container attrs = ['scaleX', 'scaleY', 'scaleZ', 'rx'] for each in attrs: if each != 'rx': var = 0.26 else: var = -90 try: cmds.setAttr ("%s.%s" % (fluid[0], each), var) except RuntimeError: cmds.setAttr ("%s.%s" % (fluid[0], each), lock = False) cmds.setAttr ("%s.%s" % (fluid[0], each), var) try: cmds.setAttr ("%sShape.gravity" % fluid[0], 1) except RuntimeError: pass debug(None, method = '_setBaseFluidAttrs', message = 'Successfully set attrs for %s:' % fluid , verbose = False)
def openTCPConnection(self, bindAddress=None): """ Open a new TCP connection from the local node to this node. """ debug("Trying to a new connection to [ " + self.getShortUid() + " ]", info=True) connector = connections.openConnection(self.getIp(), self.getPort()) if not bindAddress: bindAddress = (me.getMe().getIp(), config.getNextSendPort()) # bindAddress = twisted.internet.address.IPv4Address( # 'TCP', me.getMe().getIp(), config.SEND_PORT) # config.getNextSendPort() """ c = connections.HissTCPClientConnection.fromPrimitives( self, self.getIp(), self.getPort(), bindAddress, connector) """ """ c = connections.HissTCPClientConnection.fromPrimitives( self, self.getIp(), self.getPort(), None, connector) self._tcpConnection = c """ c = connections.HissConnection.fromPrimitives(self, self.getIp(), self.getPort(), None, connector) self._tcpConnection = c
def main(): debug("FUN TIME!") stdin = sys.stdin.readlines() threads = 5 pause = .1 slots = [None] * threads for line in stdin: user, password = line.strip().split(";")[:2] user = user.lower() for discover in discovers: passed = False tries = 0 while not passed: tries += 1 for pos in xrange(threads): if slots[pos] is None or not slots[pos].is_alive(): slots[pos] = discover(user, password) passed = True break time.sleep(pause) pause *= tries ** 0.2 * .9 if tries > 10: pause = pause * 10 + 0.001 for slot in slots: if slot is not None: slot.get_result() debug(">>> EOF !!")
def run_test(build, machine, test, path): # Open files for raw output from the victim and log data from the test raw_file_name = os.path.join(path, RAW_FILE_NAME) debug.verbose('open %s for raw output' % raw_file_name) raw_file = open(raw_file_name, 'w') # run the test, dumping the output to the raw file as we go try: debug.verbose('harness: setup test') test.setup(build, machine, path) debug.verbose('harness: run test') starttime = datetime.datetime.now() for out in test.run(build, machine, path): # timedelta for the time this line was emitted from the start of the run timestamp = datetime.datetime.now() - starttime # format as string, discarding sub-second precision timestr = str(timestamp).split('.', 1)[0] # filter output line of control characters filtered_out = filter(lambda c: c in string.printable, out.rstrip()) # debug filtered output along with timestamp debug.debug('[%s] %s' % (timestr, filtered_out)) # log full raw line (without timestamp) to output file raw_file.write(out) debug.verbose('harness: output complete') except KeyboardInterrupt: # let the user know that we are on our way out debug.error('Interrupted! Performing cleanup...') raise finally: raw_file.close() debug.verbose('harness: cleanup test') test.cleanup(machine)
def myPCall( proxy, strFuncName, args ): try: listArgs = [ proxy, strFuncName, args ]; thread.start_new_thread( LaunchCall, (listArgs,) ); return; except BaseException, err: debug.debug( "MyPCall: Exception catched: %s" % err );
def ReadBaseNameList(faction): bnl=[] debug.debug('reading base names %s', faction) filename = 'universe/fgnames/'+faction+'.txt' try: f = open (filename,'r') bnl = f.readlines() f.close() except: try: f = open ('../'+filename,'r') bnl = f.readlines() f.close() except: try: f = open ('../universe/names.txt','r') bnl = f.readlines() f.close() except: try: f = open ('universe/names.txt','r') bnl = f.readlines() f.close() except: global genericalphabet bnl=genericalphabet for i in xrange(len(bnl)): bnl[i]=bnl[i].rstrip()#.decode('utf8','ignore') import vsrandom vsrandom.shuffle(bnl) return bnl
def stop(self): if self.thread is not None: debug("Stopping async thread...") self.running = False self.thread.join() self.thread = None debug("Async thread stopped")
def ReloadUniverse(): global genUniverse, hasUniverse if cp >= 0: ShowProgress.activateProgressScreen("loading", force=True) debug.debug('Purging...') for i in fg_util.AllFactions(): fg_util.PurgeZeroShips(i) systemcount[i] = 0 debug.debug('StartSystemCount') ForEachSys(CountSystems) debug.debug(systemcount) debug.debug('EndSystemCount') genUniverse = 0 needNewUniverse = 0 curfaclist = fg_util.AllFactions() reflist = fg_util.ReadStringList(cp, "FactionRefList") if (reflist != curfaclist): needNewUniverse = 1 debug.debug('reflist is ' + str(reflist)) debug.debug('curfaclist is ' + str(curfaclist)) if (fg_util.HasLegacyFGFormat()): needNewUniverse = 1 debug.warn( 'save using legacy FG format... resetting universe to reformat' ) fg_util.DeleteLegacyFGLeftovers() if needNewUniverse: fg_util.WriteStringList(cp, "FactionRefList", curfaclist) debug.debug('generating ships... ... ...') GenerateAllShips( ) ###Insert number of flight groups and max ships per fg debug.debug('placing ships... ... ...') genUniverse = MakeUniverse() #now every system has distributed ships in the save data! else: GenerateAllShips() debug.debug("Second Load") for i in range(len(fgnames)): fg_util.origfgoffset = fgoffset[i] fgnames[i] = fg_util.TweakFGNames(origfgnames[i]) fgoffset[i] += 1 campaigns.loadAll(cp) hasUniverse = True #TODO: add ships to current system (for both modes) uru? ShowProgress.deactivateProgressScreen('loading') else: debug.error('fatal error: no cockpit')
def _create_WAKE_FluidTexture(oceanShader='', size='', pathToPreset='', wakeFluidShapeName=CONST.WAKE_FLUID_SHAPENODE): """ Create a 3d fluid texture, make it a 2d simulation and texture the waveHeightOffset of the ocean shader with it's outAlpha. @param oceanShader: @param size: @type oceanShader: @type size: """ debug(None, method='_create_WAKE_FluidTexture', message='Building fluid %s' % wakeFluidShapeName, verbose=False) fluidShape = cmds.shadingNode('fluidTexture3D', asTexture=True, name=wakeFluidShapeName) # Get parent of shape and set attrs fluid = cmds.listRelatives(fluidShape, parent=True) _setBaseFluidAttrs(fluid) ## Connect to time cmds.connectAttr("time1.outTime", (fluidShape + ".currentTime")) debug(None, method='_create_WAKE_FluidTexture', message='%s connected to time1' % fluidShape, verbose=False) ## Apply wake preset mel.eval("""applyPresetToNode " """ + fluidShape + """ " "" "" "%s" 1;""" % pathToPreset) debug(None, method='_create_WAKE_FluidTexture', message='Mel preset applied: %s' % pathToPreset, verbose=False) #expression to maintain resolution/container size relationship expStringList = [ "int $width = %s.dimensionsW;\r\n" % fluidShape, 'int $height = %s.dimensionsH;\r\n' % fluidShape, 'if ($width>= $height)\r\n', '{\r\n', '%s.baseResolution = $width*4;\r\n' % fluidShape, '}\r\n', 'else\r\n', '{\r\n%s.baseResolution = $height*4;\r\n}' % fluidShape ] utils.checkExpressionExists('waterSurfaceFluidTexture') cmds.expression(n='waterSurfaceFluidTexture', string=utils.processExpressionString(expStringList)) debug(None, method='_create_WAKE_FluidTexture', message=' Expression %s_foamTexture_ContainerSize built' % fluidShape, verbose=False) baseTextureName = wakeFluidShapeName.split('Shape')[0] cmds.rename(fluid[0], '%s' % baseTextureName) utils.createTypeTag(obj='%s' % baseTextureName, typeName='%s' % baseTextureName) debug(None, method='_create_WAKE_FluidTexture', message=' Rename and Tag successful..', verbose=False) ## Connect new wake fluid tex to ocean cmds.connectAttr("%s.outAlpha" % wakeFluidShapeName, "%s.waveHeightOffset" % oceanShader, force=True) debug(None, method='_create_WAKE_FluidTexture', message=' Returning %s:' % fluidShape, verbose=False) return fluidShape
sys.path.append('T:/software/lsapipeline/custom') import maya_genericSettings as settings import utils as utils from debug import debug import CONST as CONST #reload(utils) #reload(CONST) #reload(settings) ## METALCORE / XML STUF try: from mentalcore import mapi from mentalcore import mlib except: debug(None, method='core_archive_lib', message='metalcore mapi and mlib failed to load!!', verbose=False) pass import xml.etree.ElementTree as xml from xml.etree import ElementTree from xml.etree.ElementTree import Element, SubElement, Comment from xml.dom import minidom import tempfile import gzip def _convertOceanToPolys(): oceanName = 'ocean_srf' dispName = '%s_displacement_geo' % oceanName
def should_ignore(client): # Don't waste time on clients we'll never possibly tile if client in ignore: return True nm = ewmh.get_wm_name(client).reply() wm_class = icccm.get_wm_class(client).reply() if wm_class is not None: try: inst, cls = wm_class matchNames = set([inst.lower(), cls.lower()]) if matchNames.intersection(config.ignore): debug('Ignoring %s because it is in the ignore list' % nm) return True if hasattr(config, 'tile_only') and config.tile_only: if not matchNames.intersection(config.tile_only): debug('Ignoring %s because it is not in the tile_only ' 'list' % nm) return True except ValueError: pass if icccm.get_wm_transient_for(client).reply() is not None: debug('Ignoring %s because it is transient' % nm) ignore.append(client) return True wtype = ewmh.get_wm_window_type(client).reply() if wtype: for atom in wtype: aname = util.get_atom_name(atom) if aname in ( '_NET_WM_WINDOW_TYPE_DESKTOP', '_NET_WM_WINDOW_TYPE_DOCK', '_NET_WM_WINDOW_TYPE_TOOLBAR', '_NET_WM_WINDOW_TYPE_MENU', '_NET_WM_WINDOW_TYPE_UTILITY', '_NET_WM_WINDOW_TYPE_SPLASH', '_NET_WM_WINDOW_TYPE_DIALOG', '_NET_WM_WINDOW_TYPE_DROPDOWN_MENU', '_NET_WM_WINDOW_TYPE_POPUP_MENU', '_NET_WM_WINDOW_TYPE_TOOLTIP', '_NET_WM_WINDOW_TYPE_NOTIFICATION', '_NET_WM_WINDOW_TYPE_COMBO', '_NET_WM_WINDOW_TYPE_DND'): debug('Ignoring %s because it has type %s' % (nm, aname)) ignore.append(client) return True wstate = ewmh.get_wm_state(client).reply() if wstate is None: debug('Ignoring %s because it does not have a state' % nm) return True for atom in wstate: aname = util.get_atom_name(atom) # For now, while I decide how to handle these guys if aname == '_NET_WM_STATE_STICKY': debug('Ignoring %s because it is sticky and they are weird' % nm) return True if aname in ('_NET_WM_STATE_SHADED', '_NET_WM_STATE_HIDDEN', '_NET_WM_STATE_FULLSCREEN', '_NET_WM_STATE_MODAL'): debug('Ignoring %s because it has state %s' % (nm, aname)) return True d = ewmh.get_wm_desktop(client).reply() if d == 0xffffffff: debug('Ignoring %s because it\'s on all desktops' \ '(not implemented)' % nm) return True return False
def database(self, datas=None, type='storage', table_name=None): #type: storage | database config = configset.configset() config.configname = 'lfd.ini' dbname = config.read_config('DATABASE', 'name', value='lfd.db3') host = config.read_config('DATABASE', 'host', value='127.0.0.1') port = config.read_config('DATABASE', 'port', value='3306') dbtype = config.read_config('DATABASE', 'type', value='sqlite') username = config.read_config('DATABASE', 'username', value='root') password = config.read_config('DATABASE', 'password', value='') debug(dbname=dbname) debug(host=host) debug(port=port) debug(dbtype=dbtype) if dbtype == 'sqlite': try: # from sqlite3 import dbapi2 as sqlite import sqlite3 as sqlite except ImportError: sys.exit( "You not have module \"pysqlite2\", please download before ! \n" ) except: traceback.format_exc() sys.exit("ERROR by SYSTEM") SQL_CREATE = '''CREATE TABLE IF NOT EXISTS packages ( \ 'id' INTEGER PRIMARY KEY AUTOINCREMENT, \ 'name' VARCHAR(255) NOT NULL, \ 'description' VARCHAR(255) NOT NULL, \ 'relpath' VARCHAR(255) NOT NULL);''' SQL_CREATE_REPO = '''CREATE TABLE IF NOT EXISTS localstorage ( \ 'total' VARCHAR(255) NOT NULL, \ 'packages' VARCHAR(255) NOT NULL);''' SQL_DROP = "DROP TABLE %s;" % (table_name) conn = sqlite.connect(dbname) cursor = conn.cursor() def create(): cursor.execute(SQL_CREATE) conn.commit() cursor.execute(SQL_CREATE_REPO) conn.commit() def get(table_name): exc01 = cursor.execute('SELECT * FROM %s;' % (table_name)) conn.commit() return exc01.fetchall() def insert(): if datas: SQL_INSERT = 'INSERT INTO packages (\'name\', \'description\', \'relpath\') VALUES("%s", "%s", "%s");' % ( datas[0], convert.convert( datas[1]), convert.convert(datas[2])) SQL_INSERT_LOCALSTORAGE = 'INSERT INTO localstorage (\'total\', \'packages\') VALUES("%s", "%s");' % ( datas[0], convert.convert(datas[1])) try: # print "SQL_INSERT =", SQL_INSERT if type == 'storage': cursor.execute(SQL_INSERT_LOCALSTORAGE) elif type == 'database': cursor.execute(SQL_INSERT) conn.commit() except: if type == 'database': SQL_INSERT = "INSERT INTO packages ('name', 'relpath') VALUES('%s', '%s');" % ( datas[0], convert.convert(datas[2])) cursor.execute(SQL_INSERT) conn.commit() def truncate(table_name): cursor.execute('DELETE FROM %s;' % (table_name)) conn.commit() cursor.execute('VACUUM;') conn.commit() def drop(): cursor.execute(SQL_DROP) conn.commit() elif dbtype == 'mysql': SQL_CREATE = '''CREATE TABLE IF NOT EXISTS packages ( \ `id` BIGINT(100) AUTO_INCREMENT NOT NULL PRIMARY KEY, \ `name` VARCHAR(255) NOT NULL, \ `description` VARCHAR(255) NOT NULL, \ `relpath` VARCHAR(255) NOT NULL)''' try: import MySQLdb conn = MySQLdb.connect(host, username, password, dbname, port) cursor = conn.cursor() except ImportError: sys.exit( "You not have module \"MySQLdb\", please download before ! \n" ) except: try: conn = MySQLdb.connect(host, username, password, port=port) cursor = conn.cursor() cursor.execute(SQL_CREATE) conn.commit() except: traceback.format_exc() sys.exit("ERROR by SYSTEM") if datas: try: SQL_INSERT = "INSERT INTO packages (`name`, `description`, `relpath`) VALUES(%s, %s, %s);" % ( datas[0], datas[1], datas[2]) cursor.execute(SQL_INSERT) conn.commit() except: SQL_INSERT = "INSERT INTO packages (`name`, `description`, `relpath`) VALUES(%s, %s, %s);" % ( datas[0], ' ', datas[2]) cursor.execute(SQL_INSERT) conn.commit() elif dbtype == 'oracle': SQL_CREATE = '''CREATE TABLE IF NOT EXISTS packages ( \ 'id' BIGINT(100) GENERATED ALWAYS AS IDENTITY (START WITH 1 INCREMENT BY 1) NOT NULL PRIMARY KEY, \ 'name' VARCHAR(255) NOT NULL, \ 'description' VARCHAR(255) NOT NULL, \ 'relpath' VARCHAR(255) NOT NULL)''' sys.exit("STILL DEVELOPMENT, PLEASE USE ANOTHER DATABASE TYPE") elif dbtype == 'postgres': SQL_CREATE = '''CREATE TABLE IF NOT EXISTS packages ( \ 'id' BIGSERIAL NOT NULL PRIMARY KEY, \ 'name' VARCHAR(255) NOT NULL, \ 'description' VARCHAR(255) NOT NULL, \ 'relpath' VARCHAR(255) NOT NULL)''' try: import psycopg2 conn = psycopg2.connect( "dbname=%s, user=%s, password=%s, host=%s, port=%s" % (dbname, username, password, host, port)) cursor = conn.cursor() cursor.execute(SQL_CREATE) conn.commit() except ImportError: sys.exit( "You not have module \"Psycopg2\", please download before ! \n" ) except: traceback.format_exc() sys.exit("ERROR by SYSTEM")
def profile(self, profile): # read addon settings sVolume = ADDON.getSetting('volume') sPlayer = ADDON.getSetting('player') sVideo = ADDON.getSetting('video') sCec = ADDON.getSetting('profile' + profile + '_cec') # read settings from profile f = xbmcvfs.File(ADDON_PATH_DATA + 'profile' + profile + '.json', 'r') result = f.read() try: jsonResult = json.loads(result) f.close() except: debug.notify( ADDON_LANG(32104) + ' ' + profile + ' (' + sName[int(profile)] + ')') debug.error( '[LOAD JSON FROM FILE]: Error reading from profile - ' + str(profile)) return False # settings needed quote for value quote_needed = [ 'audiooutput.audiodevice', 'audiooutput.passthroughdevice', 'locale.audiolanguage', 'lookandfeel.soundskin' ] # set settings readed from profile file debug.notice('[RESTORING SETTING]: ' + sName[int(profile)]) for setName, setValue in jsonResult.items(): # skip setting that type is disable to changing if 'false' in sPlayer and setName.startswith('videoplayer'): continue if 'false' in sVideo and setName.startswith('videoscreen'): continue debug.debug('[RESTORING SETTING]: ' + setName + ': ' + setValue) # add quotes if setName in quote_needed: setValue = '"' + setValue + '"' # set setting if 'true' in sVolume and setName == 'volume': xbmc.executeJSONRPC( '{"jsonrpc": "2.0", "method": "Application.SetVolume", "params": {"volume": ' + jsonResult['volume'] + '}, "id": 1}') else: xbmc.executeJSONRPC( '{"jsonrpc": "2.0", "method": "Settings.SetSettingValue", "params": {"setting": "' + setName + '", "value": ' + setValue.encode('utf-8') + '}, "id": 1}') debug.notify(sName[int(profile)].decode('utf-8')) # write curent profile f = xbmcvfs.File(ADDON_PATH_DATA + 'profile', 'w') f.write(profile) f.close() # CEC if sCec != '' and int(sCec) > 0: debug.notice('[SENDING CEC COMMAND]: ' + cecCommands[int(sCec)]) xbmc.executebuiltin(cecCommands[int(sCec)])
def save(self): xbmc_version = int(xbmc.getInfoLabel('System.BuildVersion')[0:2]) debug.debug('[XBMC VERSION]: ' + str(xbmc_version)) enabledProfiles = self.getEnabledProfiles() ret = dialog.DIALOG().start('script-audio-profiles-menu.xml', labels={10071: ADDON_LANG(32100)}, buttons=enabledProfiles[1], list=10070) if ret is None: return False else: button = enabledProfiles[0][ret] settingsToSave = {} if xbmc_version < 17: json_s = [ # get all settings from System / Audio section '{"jsonrpc":"2.0","method":"Settings.GetSettings", "params":{"level": "expert", "filter":{"section":"system","category":"audiooutput"}},"id":1}', # get volume level '{"jsonrpc": "2.0", "method": "Application.GetProperties", "params": {"properties": ["volume"]}, "id": 1}', # get all settings from Video / Playback section '{"jsonrpc":"2.0","method":"Settings.GetSettings", "params":{"level": "expert", "filter":{"section":"videos","category":"videoplayer"}}, "id":1}', # get all settings from System / Video section '{"jsonrpc":"2.0","method":"Settings.GetSettings", "params":{"level": "expert", "filter":{"section":"system","category":"videoscreen"}}, "id":1}' ] else: json_s = [ # get all settings from System / Audio section '{"jsonrpc":"2.0","method":"Settings.GetSettings", "params":{"level": "expert", "filter":{"section":"system","category":"audio"}},"id":1}', # get volume level '{"jsonrpc": "2.0", "method": "Application.GetProperties", "params": {"properties": ["volume"]}, "id": 1}', # get all settings from Video / Playback section '{"jsonrpc":"2.0","method":"Settings.GetSettings", "params":{"level": "expert", "filter":{"section":"player","category":"videoplayer"}}, "id":1}', # get all settings from System / Video section '{"jsonrpc":"2.0","method":"Settings.GetSettings", "params":{"level": "expert", "filter":{"section":"system","category":"display"}}, "id":1}' ] # send json requests for j in json_s: jsonGet = xbmc.executeJSONRPC(j) jsonGet = json.loads(unicode(jsonGet, 'utf-8')) debug.debug('[JSON]: ' + str(jsonGet)) if 'result' in jsonGet: if 'settings' in jsonGet['result']: for set in jsonGet['result']['settings']: if 'value' in set.keys(): if set['value'] == True or set[ 'value'] == False: # lowercase bolean values settingsToSave[set['id']] = str( set['value']).lower() else: if type(set['value']) is int: settingsToSave[set['id']] = str( set['value']) else: settingsToSave[set['id']] = str( set['value']).encode('utf-8') if 'volume' in jsonGet['result']: settingsToSave['volume'] = str(jsonGet['result']['volume']) # prepare JSON string to save to file jsonToWrite = json.dumps(settingsToSave) # create dir in addon data if not exist if not xbmcvfs.exists(ADDON_PATH_DATA): xbmcvfs.mkdir(ADDON_PATH_DATA) # save profile file debug.notice('[SAVING SETTING]: ' + sName[button]) f = xbmcvfs.File(ADDON_PATH_DATA + 'profile' + str(button) + '.json', 'w') result = f.write(jsonToWrite) f.close() debug.notify( ADDON_LANG(32102) + ' ' + str(button) + ' (' + sName[button] + ')')
def _register_publish(self, path, name, sg_task, publish_version, tank_type, comment, thumbnail_path, dependency_paths): """ Helper method to register publish using the specified publish info. """ debug(None, method = '_register_publish', message = "path: %s" % path, verbose = False) debug(None, method = '_register_publish', message = "name: %s" % name, verbose = False) debug(None, method = '_register_publish', message = "sg_task: %s" % sg_task, verbose = False) debug(None, method = '_register_publish', message = "publish_version: %s" % publish_version, verbose = False) debug(None, method = '_register_publish', message = "tank_type: %s" % tank_type, verbose = False) debug(None, method = '_register_publish', message = "comment: %s" % comment, verbose = False) debug(None, method = '_register_publish', message = "thumbnail_path: %s" % thumbnail_path, verbose = False) debug(None, method = '_register_publish', message = "dependency_paths: %s" % dependency_paths, verbose = False) # construct args: args = { "tk": self.parent.tank, "context": self.parent.context, "comment": comment, "path": path, "name": name, "version_number": publish_version, "thumbnail_path": thumbnail_path, "task": sg_task, "dependency_paths": dependency_paths, "published_file_type":tank_type, } self.parent.log_debug("Register publish in shotgun: %s" % str(args)) debug(None, method = '_register_publish', message = "args: %s" % str(args), verbose = False) debug(None, method = '_register_publish', message = "Registering the publish now...", verbose = False) # register publish; sg_data = tank.util.register_publish(**args) return sg_data
def execute(self, tasks, work_template, progress_cb, **kwargs): """ Main hook entry point :tasks: List of tasks to be pre-published. Each task is be a dictionary containing the following keys: { item: Dictionary This is the item returned by the scan hook { name: String description: String type: String other_params: Dictionary } output: Dictionary This is the output as defined in the configuration - the primary output will always be named 'primary' { name: String publish_template: template tank_type: String } } :work_template: template This is the template defined in the config that represents the current work file :progress_cb: Function A progress callback to log progress during pre-publish. Call: progress_cb(percentage, msg) to report progress to the UI :returns: A list of any tasks that were found which have problems that need to be reported in the UI. Each item in the list should be a dictionary containing the following keys: { task: Dictionary This is the task that was passed into the hook and should not be modified { item:... output:... } errors: List A list of error messages (strings) to report } """ results = [] # validate tasks: for task in tasks: item = task["item"] output = task["output"] errors = [] # report progress: progress_cb(0, "Validating", task) if item["type"] == "fx_caches": debug(app=None, method='shotFX_PrePublishHook', message='fx_caches type found', verbose=False) errors.extend(self._validate_item_for_publish(item)) elif item["type"] == "nparticle_caches": debug(app=None, method='shotFX_PrePublishHook', message='nparticle_caches type found', verbose=False) errors.extend(self._validate_item_for_publish(item)) elif item["type"] == "fx_renders": debug(app=None, method='shotFX_PrePublishHook', message='fx_renders type found', verbose=False) errors.extend(self._validate_item_for_publish(item)) else: # don't know how to publish this output types! errors.append( "Don't know how to publish this item! \nPlease contact your supervisor or lead..." % output["name"]) # if there is anything to report then add to result if len(errors) > 0: # add result: results.append({"task": task, "errors": errors}) progress_cb(100) return results
def _do_maya_publish(self, task, work_template, comment, thumbnail_path, sg_task, progress_cb): """ Publish the main Maya scene """ import maya.cmds as cmds progress_cb(0.0, "Finding scene dependencies", task) dependencies = self._maya_find_additional_scene_dependencies() debug(None, method = '_do_maya_publish', message = 'dependencies: %s' % dependencies, verbose = False) ## Get scene path scene_path = os.path.abspath(cmds.file(query=True, sn= True)) debug(None, method = '_do_maya_publish', message = 'scene_path: %s' % scene_path, verbose = False) ## Test if it's a valid scene path if not work_template.validate(scene_path): raise TankError("File '%s' is not a valid work path, unable to publish!" % scene_path) ## Use templates to convert to publish path: output = task["output"] fields = work_template.get_fields(scene_path) fields["TankType"] = output["tank_type"] ## Now update the name to be the actual assetName from shotgun and remove the _ for saving fields['name'] = fields['Shot'].replace('_', '') publish_template = output["publish_template"] publish_path = publish_template.apply_fields(fields) if os.path.exists(publish_path): debug(None, method = '_do_maya_publish', message = 'Publish path exists! Altering file v# now', verbose = False) ## If it already exists version up one. ## We should never fail a publish just because a published asset already exists cmds.warning('Found existing publish_path: %s' % publish_path) cmds.warning('Adjusting publish_path now...') path = '\\'.join(publish_path.split('\\')[0:-1]) getfiles = os.listdir(path) debug(None, method = '_do_maya_publish', message = 'path: %s' % path, verbose = False) if 'Keyboard' in getfiles: getfiles.remove('Keyboard') ## legacy check remove any ma files from the list as we're now publishing only to mb! for each in getfiles: if not each.endswith('mb'): getfiles.remove(each) ## Now process the rest of the list.. ## Get the max of the list highestVersFile = max(getfiles).split('.')[1].split('v')[-1] ## Update the fields with a new version number fields["version"] = int(highestVersFile) + 1 ## Apply the fields to the templates paths.. publish_path = publish_template.apply_fields(fields) ## Output the new publish path to the scripteditor cmds.warning('NewPublishPath: %s' % publish_path) debug(None, method = '_do_maya_publish', message = 'NEW publish_path: %s' % publish_path, verbose = False) ## Save the scene so we have a valid os.rename path progress_cb(10.0, "Saving the current working scene") self.parent.log_debug("Saving the current working scene...") publish_name = self._get_publish_name(publish_path, publish_template, fields) if fields['version'] < 10: padding = '00' elif fields['version'] < 100: padding = '0' else: padding = '' cmds.file(rename = '%s.v%s%s' % (publish_name, padding, fields['version'])) cmds.file(save=True, force= True) debug(None, method = '_do_maya_publish', message = 'Saved scene to %s.v%s%s' % (publish_name, padding, fields['version']), verbose = False) print 'Saved scene to %s.v%s%s' % (publish_name, padding, fields['version']) progress_cb(50.0, "Publishing the file to publish area") try: publish_folder = os.path.dirname(publish_path) self.parent.ensure_folder_exists(publish_folder) debug(None, method = '_do_maya_publish', message = 'publish_folder: %s' % publish_folder, verbose = False) getCurrentScenePath = os.path.abspath(cmds.file(query=True, sn= True)) os.rename(getCurrentScenePath, publish_path) self.parent.log_debug("Publishing %s --> %s..." % (getCurrentScenePath, publish_path)) debug(None, method = '_do_maya_publish', message = "Publishing %s --> %s..." % (getCurrentScenePath, publish_path), verbose = False) progress_cb(65.0, "Moved the publish") except Exception, e: raise TankError("Failed to copy file: \n%s \nto\n%s\nError: %s" % (getCurrentScenePath, publish_path, e))
def processTemplates(self, tk, templateFile='', id='', shotNum='', inprogressBar='', type=''): """ Used to fetch most recent publishes @param tk : tank instance @param templateFile: the tank template file specified in the shot_step.yml #param assetDict: dict in format assetName, assetParent @type templateFile: template """ ## Now fetch all the template paths from shotgun getTemplatePaths = tk.paths_from_template(templateFile, { 'Step': 'Light', 'id': id, 'Shot': shotNum }) debug(app=self, method='processTemplates', message='getTemplatePaths: %s' % getTemplatePaths, verbose=False) ## Now look for each assets template path: xmlFile = max(getTemplatePaths) debug(app=self, method='processTemplates', message='Max Version xmlFile.... %s' % xmlFile, verbose=False) ## Now if versions has stuff in it.. if not xmlFile: debug(app=self, method='processTemplates', message='Can not find any xml files for %s' % shotNum, verbose=False) pass else: debug(app=self, method='processTemplates', message='Valid Xml Path?: %s' % os.path.isfile(xmlFile.replace(os.path.sep, "/")), verbose=False) if os.path.isfile(xmlFile.replace( os.path.sep, "/")): ## is this a valid xml file!? if type == 'lighting': inprogressBar.updateProgress( percent=35, doingWhat='Rebuilding Lights XML...') debug(app=self, method='processTemplates', message='Loading Lighting XML NOW...', verbose=False) read_light_xml.actionLightXML( pathToXML=xmlFile.replace(os.path.sep, "/")) debug(app=self, method='processTemplates', message='Lighting XML Load Complete...', verbose=False) elif type == 'shaders': inprogressBar.updateProgress( percent=20, doingWhat='createAll shaders...') shd.createAll(XMLPath=xmlFile.replace(os.path.sep, "/"), parentGrp='', Namespace='', Root='MaterialNodes') inprogressBar.updateProgress( percent=30, doingWhat='connectAll shaders...') shd.connectAll(XMLPath=xmlFile.replace(os.path.sep, "/"), parentGrp='', Namespace='', Root='MaterialNodes') elif type == 'renderglobals': ## this render globals inprogressBar.updateProgress( percent=45, doingWhat= 'recreating renderglobals and render passes now.....') readXML.readCoreData( pathToXML=xmlFile.replace(os.path.sep, "/")) inprogressBar.updateProgress( percent=50, doingWhat= 'renderglobals and render passes recreated.....') else: pass else: debug( app=self, method='processTemplates', message= 'FAILED Can not find a valid published xml file for %s ...' % os.path.isfile(xmlFile.replace(os.path.sep, "/")), verbose=False) pass
class PrimaryPublishHook(Hook): """ Single hook that implements publish of the primary task """ def execute(self, task, work_template, comment, thumbnail_path, sg_task, progress_cb, **kwargs): """ Main hook entry point :task: Primary task to be published. This is a dictionary containing the following keys: { item: Dictionary This is the item returned by the scan hook { name: String description: String type: String other_params: Dictionary } output: Dictionary This is the output as defined in the configuration - the primary output will always be named 'primary' { name: String publish_template: template tank_type: String } } :work_template: template This is the template defined in the config that represents the current work file :comment: String The comment provided for the publish :thumbnail: Path string The default thumbnail provided for the publish :sg_task: Dictionary (shotgun entity description) The shotgun task to use for the publish :progress_cb: Function A progress callback to log progress during pre-publish. Call: progress_cb(percentage, msg) to report progress to the UI :returns: Path String Hook should return the path of the primary publish so that it can be passed as a dependency to all secondary publishes Hook should raise a TankError if publish of the primary task fails """ # get the engine name from the parent object (app/engine/etc.) engine_name = self.parent.engine.name # depending on engine: if engine_name == "tk-maya": return self._do_maya_publish(task, work_template, comment, thumbnail_path, sg_task, progress_cb) else: raise TankError("Unable to perform publish for unhandled engine %s \n Check with your TD that the config is loading the right primary publish hook." % engine_name) def _do_maya_publish(self, task, work_template, comment, thumbnail_path, sg_task, progress_cb): """ Publish the main Maya scene """ import maya.cmds as cmds progress_cb(0.0, "Finding scene dependencies", task) dependencies = self._maya_find_additional_scene_dependencies() debug(None, method = '_do_maya_publish', message = 'dependencies: %s' % dependencies, verbose = False) ## Get scene path scene_path = os.path.abspath(cmds.file(query=True, sn= True)) debug(None, method = '_do_maya_publish', message = 'scene_path: %s' % scene_path, verbose = False) ## Test if it's a valid scene path if not work_template.validate(scene_path): raise TankError("File '%s' is not a valid work path, unable to publish!" % scene_path) ## Use templates to convert to publish path: output = task["output"] fields = work_template.get_fields(scene_path) fields["TankType"] = output["tank_type"] ## Now update the name to be the actual assetName from shotgun and remove the _ for saving fields['name'] = fields['Shot'].replace('_', '') publish_template = output["publish_template"] publish_path = publish_template.apply_fields(fields) if os.path.exists(publish_path): debug(None, method = '_do_maya_publish', message = 'Publish path exists! Altering file v# now', verbose = False) ## If it already exists version up one. ## We should never fail a publish just because a published asset already exists cmds.warning('Found existing publish_path: %s' % publish_path) cmds.warning('Adjusting publish_path now...') path = '\\'.join(publish_path.split('\\')[0:-1]) getfiles = os.listdir(path) debug(None, method = '_do_maya_publish', message = 'path: %s' % path, verbose = False) if 'Keyboard' in getfiles: getfiles.remove('Keyboard') ## legacy check remove any ma files from the list as we're now publishing only to mb! for each in getfiles: if not each.endswith('mb'): getfiles.remove(each) ## Now process the rest of the list.. ## Get the max of the list highestVersFile = max(getfiles).split('.')[1].split('v')[-1] ## Update the fields with a new version number fields["version"] = int(highestVersFile) + 1 ## Apply the fields to the templates paths.. publish_path = publish_template.apply_fields(fields) ## Output the new publish path to the scripteditor cmds.warning('NewPublishPath: %s' % publish_path) debug(None, method = '_do_maya_publish', message = 'NEW publish_path: %s' % publish_path, verbose = False) ## Save the scene so we have a valid os.rename path progress_cb(10.0, "Saving the current working scene") self.parent.log_debug("Saving the current working scene...") publish_name = self._get_publish_name(publish_path, publish_template, fields) if fields['version'] < 10: padding = '00' elif fields['version'] < 100: padding = '0' else: padding = '' cmds.file(rename = '%s.v%s%s' % (publish_name, padding, fields['version'])) cmds.file(save=True, force= True) debug(None, method = '_do_maya_publish', message = 'Saved scene to %s.v%s%s' % (publish_name, padding, fields['version']), verbose = False) print 'Saved scene to %s.v%s%s' % (publish_name, padding, fields['version']) progress_cb(50.0, "Publishing the file to publish area") try: publish_folder = os.path.dirname(publish_path) self.parent.ensure_folder_exists(publish_folder) debug(None, method = '_do_maya_publish', message = 'publish_folder: %s' % publish_folder, verbose = False) getCurrentScenePath = os.path.abspath(cmds.file(query=True, sn= True)) os.rename(getCurrentScenePath, publish_path) self.parent.log_debug("Publishing %s --> %s..." % (getCurrentScenePath, publish_path)) debug(None, method = '_do_maya_publish', message = "Publishing %s --> %s..." % (getCurrentScenePath, publish_path), verbose = False) progress_cb(65.0, "Moved the publish") except Exception, e: raise TankError("Failed to copy file: \n%s \nto\n%s\nError: %s" % (getCurrentScenePath, publish_path, e)) print debug(None, method = '_do_maya_publish', message = "publish_path: %s" % publish_path, verbose = False) debug(None, method = '_do_maya_publish', message = "publishName: %s_LAYOUT" % publish_name, verbose = False) debug(None, method = '_do_maya_publish', message = "sg_task: %s" % sg_task, verbose = False) debug(None, method = '_do_maya_publish', message = "publish_version: %s" % fields["version"], verbose = False) debug(None, method = '_do_maya_publish', message = "tank_type: %s" % output["tank_type"], verbose = False) debug(None, method = '_do_maya_publish', message = "comment: %s" % comment, verbose = False) debug(None, method = '_do_maya_publish', message = "thumbnail_path: %s" % thumbnail_path, verbose = False) debug(None, method = '_do_maya_publish', message = "dependencies: %s" % dependencies, verbose = False) # finally, register the publish: progress_cb(75.0, "Registering the publish") self._register_publish(publish_path, '%s_LAYOUT'%publish_name, sg_task, fields["version"], output["tank_type"], comment, thumbnail_path, dependencies) progress_cb(100) ## Now put it back to Ascii cmds.file(save=True, force=True, type = 'mayaAscii') return publish_path
def opened(self): '''Call callback on_opened''' debug('Connected to the data server :D') if 'on_opened' in dir(self): self.on_opened()
def run_app(self): """ Callback from when the menu is clicked. """ ## Tell the artist to be patient... eg not genY inprogressBar = pbui.ProgressBarUI(title='Rebuilding Lighting Scene:') inprogressBar.show() inprogressBar.updateProgress(percent=1, doingWhat='Processing scene info...') ## Instantiate the API tk = sgtk.sgtk_from_path("T:/software/bubblebathbay") debug(app=self, method='run_app', message='API instanced...\n%s' % tk, verbose=False) debug(app=self, method='run_app', message='Fetch Lighting Assets launched...', verbose=False) context = self.context ## To get the step debug(app=self, method='run_app', message='Context Step...\n%s' % context.step['name'], verbose=False) if context.step['name'] != 'Light': inprogressBar.close() cmds.warning( "Current context is not a valid Lighting context. Please make sure you are under a valid shotgun Lighting context!" ) scene_path = '%s' % os.path.abspath(cmds.file(query=True, sn=True)) debug(app=self, method='run_app', message='scene_path... %s' % scene_path, verbose=False) ## Build an entity type to get some values from. entity = self.context.entity ## returns {'type': 'Shot', 'name': 'ep100_sh010', 'id': 1166} debug(app=self, method='run_app', message='entity... %s' % entity, verbose=False) ## Filter for the matching ID for the shot sg_filters = [["id", "is", entity["id"]]] debug(app=self, method='run_app', message='sg_filters... %s' % sg_filters, verbose=False) ## Build an entity type to get some values from. sg_entity_type = self.context.entity["type"] ## returns Shot debug(app=self, method='run_app', message='sg_entity_type...\n%s' % sg_entity_type, verbose=False) ## DATA ## NOTES SO HERE WE DON'T NEED TO CALL THE ASSETS FIELD FROM SHOTGUN ## WE CAN JUST GRAB THE LATEST PUBLISH FILE FROM EACH OF THE TEMPLATE STEPS inprogressBar.updateProgress(percent=3, doingWhat='Processing scene info...') shadersTemplate = tk.templates[self.get_setting( 'maya_shot_SHD_XML_template')] debug(app=self, method='run_app', message='shadersTemplate...\n%s' % shadersTemplate, verbose=False) lightingTemplate = tk.templates[self.get_setting( 'maya_shot_lighting_template')] debug(app=self, method='run_app', message='lightingTemplate...\n%s' % lightingTemplate, verbose=False) renderglobalsTemplate = tk.templates[self.get_setting( 'maya_shot_renderglobals_template')] debug(app=self, method='run_app', message='renderglobalsTemplate...\n%s' % lightingTemplate, verbose=False) ## PROCESS TEMPLATE NOW inprogressBar.updateProgress(percent=5, doingWhat='Processing shaders xml...') debug(app=self, method='run_app', message='Processing template... %s' % shadersTemplate, verbose=False) ## SHADERS self.processTemplates(tk=tk, templateFile=shadersTemplate, id=entity["id"], shotNum=entity["name"], inprogressBar=inprogressBar, type='shaders') ## Attach ocean shader now... shd.oceanAttach(self) ## LIGHTS inprogressBar.updateProgress(percent=32, doingWhat='Processing lights xml...') self.processTemplates(tk=tk, templateFile=lightingTemplate, id=entity["id"], shotNum=entity["name"], inprogressBar=inprogressBar, type='lighting') ## Render globals inprogressBar.updateProgress( percent=40, doingWhat='Processing renderglobals xml...') self.processTemplates(tk=tk, templateFile=renderglobalsTemplate, id=entity["id"], shotNum=entity["name"], inprogressBar=inprogressBar, type='renderglobals') ## Attach subDiv settings.attachMentalRaySubDiv() ## Now cleanup inprogressBar.updateProgress(percent=90, doingWhat='Cleaning...') cleanup.shotCleanupLights() inprogressBar.close() inprogressBar = None ############################################ ## CORE ACHIVES ## Now process the assembly References debug(app=self, method='run_app', message='Processing mentalCore assemblies..', verbose=False) inprogressBar = pbui.ProgressBarUI(title='Rebuilding Core Archives:') inprogressBar.show() inprogressBar.updateProgress(percent=0, doingWhat='Processing core archives...') if cmds.objExists('CORE_ARCHIVES_hrc') or cmds.objExists( 'CORE_ARCHIVES_hrc'): inprogressBar.updateProgress(percent=100, doingWhat='Complete...') inprogressBar.close() inprogressBar = None else: ## Get the assembly paths from the transforms in the scene with the correct tags to load now.. self.getAssemblyPaths = coreLib.getCorePaths() debug(app=self, method='run_app', message='self.getAssemblyPaths.. %s' % self.getAssemblyPaths, verbose=False) if self.getAssemblyPaths: ## Now load the assemblies from the paths coreLib.loadCoreArchives(paths=self.getAssemblyPaths) debug( app=self, method='run_app', message= 'self.loadCoreArchives Successful all assemblies loaded moving on to reconnect now...', verbose=False) inprogressBar.updateProgress( percent=40, doingWhat='Core archives loaded...') ## Now connect the assemblies. inprogressBar.updateProgress( percent=60, doingWhat='Reconnecting core archives...') coreLib.doReconnect() debug( app=self, method='run_app', message= 'Ahh core archive assemblies reconnected successfully!!...', verbose=False) cleanup.shotCleanupPlacements() cmds.group([ 'CORE_ARCHIVES_hrc', 'REBUILT_CORE_ARCHIVES_hrc', 'placements_hrc', 'LIGHTS_hrc' ], n='LIGHTING_hrc', em=False) else: pass inprogressBar.updateProgress(percent=100, doingWhat='COMPLETE...') inprogressBar.close() inprogressBar = None
def _publish_ocean_for_item(self, item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb): """ Export an xml file for the specified item and publish it to Shotgun. """ debug(app = None, method = '_publish_ocean_for_item', message = 'Processing item: %s' % item['name'], verbose = False) group_name = '%s' % ''.join(item["name"].strip("|").split('_hrc')[0].split('_')) debug(app = None, method = '_publish_ocean_for_item', message = 'group_name: %s' % group_name, verbose = False) tank_type = output["tank_type"] debug(app = None, method = '_publish_ocean_for_item', message = 'tank_type: %s' % tank_type, verbose = False) publish_template = output["publish_template"] debug(app = None, method = '_publish_ocean_for_item', message = 'publish_template: %s' % publish_template, verbose = False) # get the current scene path and extract fields from it # using the work template: scene_path = os.path.abspath(cmds.file(query=True, sn= True)) fields = work_template.get_fields(scene_path) publish_version = fields["version"] # update fields with the group name: fields["grp_name"] = group_name ## create the publish path by applying the fields ## with the publish template: publish_path = publish_template.apply_fields(fields) debug(app = None, method = '_publish_ocean_for_item', message = 'FINAL publish_path: %s' % publish_path, verbose = False) ## Make the directory now... if not os.path.isdir(os.path.dirname(publish_path)): debug(app = None, method = '_publish_ocean_for_item', message = 'Building dir: %s' % os.path.dirname(publish_path), verbose = False) os.mkdir(os.path.dirname(publish_path)) try: self.parent.log_debug("Executing command: OCEAN EXPORT!") print '=====================' print 'Exporting the ocean and fluids %s' % publish_path ## Now export cmds.select(item['name'], r = True) cmds.file(publish_path, force = True, options = "v=0;", typ = "mayaAscii", es = True) ## Now register publish with shotgun self._register_publish(publish_path, group_name, sg_task, publish_version, tank_type, comment, thumbnail_path, [primary_publish_path]) print 'Finished ocean and fluids export...' print '=====================' except Exception, e: raise TankError("Failed to export %s" % group_name)
def closed(self, code, reason): '''Call callback on_closed.''' debug(("Closed down :(", code, reason)) if 'on_closed' in dir(self): self.on_closed(self.data)
def execute(self, tasks, work_template, comment, thumbnail_path, sg_task, primary_publish_path, progress_cb, **kwargs): """ Main hook entry point :tasks: List of secondary tasks to be published. Each task is a dictionary containing the following keys: { item: Dictionary This is the item returned by the scan hook { name: String description: String type: String other_params: Dictionary } output: Dictionary This is the output as defined in the configuration - the primary output will always be named 'primary' { name: String publish_template: template tank_type: String } } :work_template: template This is the template defined in the config that represents the current work file :comment: String The comment provided for the publish :thumbnail: Path string The default thumbnail provided for the publish :sg_task: Dictionary (shotgun entity description) The shotgun task to use for the publish :primary_publish_path: Path string This is the path of the primary published file as returned by the primary publish hook :progress_cb: Function A progress callback to log progress during pre-publish. Call: progress_cb(percentage, msg) to report progress to the UI :returns: A list of any tasks that had problems that need to be reported in the UI. Each item in the list should be a dictionary containing the following keys: { task: Dictionary This is the task that was passed into the hook and should not be modified { item:... output:... } errors: List A list of error messages (strings) to report } """"" results = [] errors = [] ## PROCESS STUFF BEFORE DOWNGRADING shadingDone = False for task in tasks: debug(app = None, method = 'lightingSecPublish.execute', message = 'task: %s' % task, verbose = False) item = task["item"] debug(app = None, method = 'lightingSecPublish.execute', message = 'item: %s' % item, verbose = False) output = task["output"] # report progress: ### SHD XML if output["name"] == 'shd_xml': progress_cb(0, "Publishing SHD xml now...") # type: mesh_grp ## Because shading exports from the shaders and not the actual groups we can just run this step ONCE! ## If we do this for every item we're wasting serious time outputting the same thing over and over. if not shadingDone: try: debug(app = None, method = 'lightingSecPublish.execute', message = 'item: %s' % item, verbose = False) self._publish_shading_xml_for_item(item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb) ## Now fix the fileNodes back to a work folder structure not the publish folder structure self.repathFileNodesForWork() shadingDone = True debug(app = None, method = 'lightingSecPublish.execute', message = 'shadingDone: %s' % shadingDone, verbose = False) except Exception, e: errors.append("Publish failed - %s" % e) else: pass ### LIGHTS XML elif output["name"] == 'lights_xml': progress_cb(0, "Publishing Light xml now...") # type: light_grp ## Because we have only found in the scan scene just the LIGHTS_hrc group there should only be one light item to process... try: self._publish_lighting_xml_for_item(item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb) except Exception, e: errors.append("Publish failed - %s" % e)
def submitFinalToDeadline(self, item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb): debug(app = None, method = 'submitPreviewToDeadline', message = 'Entered submitPreviewToDeadline' , verbose = False) render_name = '%s_%s' % ('_'.join( self._getMostRecentPublish()[0].split('.')[:-1] ), item['name']) debug(app = None, method = 'submitPreviewToDeadline', message = 'render_name: %s' % render_name, verbose = False) tank_type = output["tank_type"] debug(app = None, method = 'submitPreviewToDeadline', message = 'tank_type: %s' % tank_type, verbose = False) publish_template = output["publish_template"] debug(app = None, method = 'submitPreviewToDeadline', message = 'publish_template: %s' % publish_template, verbose = False) # get the current scene path and extract fields from it # using the work template: scene_path = os.path.abspath(cmds.file(query=True, sn= True)) fields = work_template.get_fields(scene_path) publish_version = fields["version"] # update fields with the group name: fields["grp_name"] = render_name ## BUILD THE Job Info File for deadline ##deadlinecommand.exe [Job Info File] [Plug-in Info File] publish_path = publish_template.apply_fields(fields) debug(app = None, method = 'submitPreviewToDeadline', message = 'FINAL publish_path: %s' % publish_path, verbose = False) ## define log paths etc logTo = r'%s/deadlinebg_output' % tempfile.gettempdir().replace('\\', '/') jobInfoPath = r'%s/maya_job_info.job' % tempfile.gettempdir().replace('\\', '/') pluginInfoPath = r'%s/maya_plugin_info.job' % tempfile.gettempdir().replace('\\', '/') debug(app = None, method = 'submitPreviewToDeadline', message = 'logTo: %s' % logTo, verbose = False) debug(app = None, method = 'submitPreviewToDeadline', message = 'jobInfoPath: %s' % jobInfoPath, verbose = False) debug(app = None, method = 'submitPreviewToDeadline', message = 'pluginInfoPath: %s' % pluginInfoPath, verbose = False) ## Job Info stuff jobname = '.'.join( self._getMostRecentPublish()[0].split('.')[:-1] ) debug(app = None, method = 'submitPreviewToDeadline', message = 'jobname: %s' % jobname, verbose = False) projectPath = cmds.workspace(query = True, fullName = True) debug(app = None, method = 'submitPreviewToDeadline', message = 'projectPath: %s' % projectPath, verbose = False) outputFilePath = publish_path debug(app = None, method = 'submitPreviewToDeadline', message = 'outputFilePath: %s' % outputFilePath, verbose = False) ## check and build output path if it doesn't exist if not os.path.isdir(outputFilePath): os.mkdir(outputFilePath) sceneFilePath = os.path.join(self._getMostRecentPublish()[1], self._getMostRecentPublish()[0]).replace('\\', '/') debug(app = None, method = 'submitPreviewToDeadline', message = 'sceneFilePath: %s' % sceneFilePath, verbose = False) ouputFileName = '_'.join((self._getMostRecentPublish()[0].split('.'))) debug(app = None, method = 'submitPreviewToDeadline', message = 'ouputFileName: %s' % ouputFileName, verbose = False) comment = comment debug(app = None, method = 'submitPreviewToDeadline', message = 'comment: %s' % comment, verbose = False) version = '2013.5' debug(app = None, method = 'submitPreviewToDeadline', message = 'version: %s' % version, verbose = False) pool = 'maya' debug(app = None, method = 'submitPreviewToDeadline', message = 'pool: %s' % pool, verbose = False) machineLimit = 5 debug(app = None, method = 'submitPreviewToDeadline', message = 'machineLimit: %s' % machineLimit, verbose = False) priority = 100 debug(app = None, method = 'submitPreviewToDeadline', message = 'priority: %s' % priority, verbose = False) taskTimeoutMinutes = 240 debug(app = None, method = 'submitPreviewToDeadline', message = 'taskTimeoutMinutes: %s' % taskTimeoutMinutes, verbose = False) minRenderTimeMinutes = 0 debug(app = None, method = 'submitPreviewToDeadline', message = 'minRenderTimeMinutes: %s' % minRenderTimeMinutes, verbose = False) concurrentTasks = 1 debug(app = None, method = 'submitPreviewToDeadline', message = 'concurrentTasks: %s' % concurrentTasks, verbose = False) department = getuser() debug(app = None, method = 'submitPreviewToDeadline', message = 'department: %s' % department, verbose = False) limitGroups = 0 debug(app = None, method = 'submitPreviewToDeadline', message = 'limitGroups: %s' % limitGroups, verbose = False) renderer = 'MentalRay' debug(app = None, method = 'submitPreviewToDeadline', message = 'renderer: %s' % renderer, verbose = False) autoMemoryLimit = 1 debug(app = None, method = 'submitPreviewToDeadline', message = 'autoMemoryLimit: %s' % autoMemoryLimit, verbose = False) memoryLimit = 1 debug(app = None, method = 'submitPreviewToDeadline', message = 'memoryLimit: %s' % memoryLimit, verbose = False) camera = self._getShotCam() debug(app = None, method = 'submitPreviewToDeadline', message = 'camera: %s' % camera, verbose = False) startFrame = cmds.playbackOptions(query = True, animationStartTime = True) endFrame = cmds.playbackOptions(query = True, animationEndTime = True) ## Process the data into the right formats submitString = [ 'Plugin=MayaBatch', 'Name=%s' % jobname, 'Comment=%s' % comment, 'Department=%s' % department, 'Pool=%s' % pool, 'Group=none', 'Priority=%s' % priority, 'TaskTimeoutMinutes=%s' % taskTimeoutMinutes, 'EnableAutoTimeout=False', 'ConcurrentTasks=%s' % concurrentTasks, 'LimitConcurrentTasksToNumberOfCpus=True', 'MachineLimit=%s' % machineLimit, 'Whitelist=', 'LimitGroups=', 'JobDependencies=', 'OnJobComplete=Nothing', 'Frames=%s-%s' % (int(startFrame), int(endFrame)), 'ChunkSize=1', 'OutputDirectory0=%s/' % outputFilePath, ] ## write to file jobInfoFile = open(jobInfoPath, "w") for eachLine in submitString: jobInfoFile.write('%s\n' % eachLine) jobInfoFile.close() debug(app = None, method = 'submitFinalToDeadline', message = 'Wrote jobInfoFile successfully...', verbose = False) ### Plugin Info File _MAYA_PLUGIN_INFO_ATTRS = [ 'SceneFile=%s' %(str(cmds.file(q = 1, sceneName = 1)).replace('\\', '/')), 'Version=%s' % version, 'Build=64bit', 'ProjectPath=//192.168.5.253/BBB_main/bbb', 'StrictErrorChecking=False', 'LocalRendering=True', 'MaxProcessors=0', 'OutputFilePath=%s/' % outputFilePath, 'Renderer=%s' % renderer, 'MentalRayVerbose=Progress Messages', 'AutoMemoryLimit=True', 'MemoryLimit=0', 'CommandLineOptions=', 'UseOnlyCommandLineOptions=0', 'IgnoreError211=False', 'Camera=%s' % [cam for cam in cmds.ls(type = 'camera') if 'shotCam_bake' in cam][0].replace('Shape', ''), ] ## write to file pluginInfoFile = open(pluginInfoPath, "w") for eachLine in _MAYA_PLUGIN_INFO_ATTRS: pluginInfoFile.write('%s\n' % eachLine) pluginInfoFile.close() debug(app = None, method = 'submitFinalToDeadline', message = 'Wrote pluginInfoFile successfully...', verbose = False) try: self.parent.log_debug("Executing command: RENDER FINAL!") print '=====================' print 'Submitting to deadlines %s' % publish_path subprocess.call( 'Deadlinecommand.exe %s %s %s' % (jobInfoPath, pluginInfoPath, sceneFilePath) ) ## Now register publish with shotgun self._register_publish(publish_path, render_name, sg_task, publish_version, tank_type, comment, thumbnail_path, [primary_publish_path]) print 'Finished submitting render preview to deadline.....' print '=====================' except Exception, e: raise TankError("Failed to export %s" % render_name)
self._publish_ocean_for_item(item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb) except Exception, e: errors.append("Publish failed - %s" % e) # elif output["name"] == 'renderPreview': # progress_cb(0, "Publishing Render Preview to Deadline now...") # ## Export the renderPreview found to submit to deadline # try: # debug(app = None, method = 'lightingSecPublish.execute.renderPreview', message = 'item: %s' % item, verbose = False) # self.submitPreviewToDeadline(item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb) # except Exception, e: # errors.append("Publish failed - %s" % e) elif output["name"] == 'renderFinal': progress_cb(0, "Publishing Render Final to Deadline now...") ## Export the renderFinal found to submit to deadline try: debug(app = None, method = 'lightingSecPublish.execute.renderFinal', message = 'item: %s' % item, verbose = False) self.submitFinalToDeadline(item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb) except Exception, e: errors.append("Publish failed - %s" % e) elif output["name"] == 'renderglobals_xml': progress_cb(0, "Publishing renderglobals_xml now...") ## Export the renderglobals_xml try: debug(app = None, method = 'lightingSecPublish.execute.renderglobals_xml', message = 'item: %s' % item, verbose = False) self._publish_renderglobals_xml_for_item(item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb) except Exception, e: errors.append("Publish failed - %s" % e) else: # don't know how to publish this output types! errors.append("Don't know how to publish this item!")
def _publish_nukeCamera_for_item(self, item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb): """ Export an xml file for the specified item and publish it to Shotgun. """ debug(app = None, method = '_publish_nukeCamera_for_item', message = 'item["name"]: %s' % item["name"], verbose = False) tank_type = output["tank_type"] debug(app = None, method = '_publish_nukeCamera_for_item', message = 'tank_type: %s' % tank_type, verbose = False) publish_template = output["publish_template"] debug(app = None, method = '_publish_nukeCamera_for_item', message = 'publish_template: %s' % publish_template, verbose = False) # get the current scene path and extract fields from it # using the work template: scene_path = os.path.abspath(cmds.file(query=True, sn= True)) fields = work_template.get_fields(scene_path) publish_version = fields["version"] ## create the publish path by applying the fields ## with the publish template: try: print '=====================' print 'Exporting the nukeCamera' startFrame = cmds.playbackOptions(query =True, animationStartTime = True) debug(app = None, method = '_publish_nukeCamera_for_item', message = 'startFrame: %s' % startFrame, verbose = False) endFrame = cmds.playbackOptions(query =True, animationEndTime= True) debug(app = None, method = '_publish_nukeCamera_for_item', message = 'endFrame: %s' % endFrame, verbose = False) cleanup.turnOffModelEditors() shotCams = [] for eachCamera in cmds.listRelatives(item["name"], children = True): if cmds.getAttr('%s.type' % eachCamera) == 'shotCam': debug(app = None, method = '_publish_nukeCamera_for_item', message = 'eachCamera: %s' % eachCamera, verbose = False) shotCams.extend([eachCamera]) debug(app = None, method = '_publish_nukeCamera_for_item', message = 'shotCams: %s' % shotCams, verbose = False) debug(app = None, method = '_publish_nukeCamera_for_item', message = 'len(shotCams): %s' % len(shotCams), verbose = False) group_name = '' if len(shotCams) == 1: # update fields with the group name: group_name = '%s_NUKECAM' % shotCams[0] fields["grp_name"] = group_name debug(app = None, method = '_publish_nukeCamera_for_item', message = 'grp_name: %s' % group_name, verbose = False) fields["cam_name"] = shotCams[0] debug(app = None, method = '_publish_nukeCamera_for_item', message = 'cam_name: %s' % shotCams[0], verbose = False) publish_path = publish_template.apply_fields(fields) debug(app = None, method = '_publish_nukeCamera_for_item', message = 'FINAL publish_path: %s' % publish_path, verbose = False) ## Make the directory now... if not os.path.isdir(os.path.dirname(publish_path)): debug(app = None, method = '_publish_nukeCamera_for_item', message = 'Building dir: %s' % os.path.dirname(publish_path), verbose = False) os.mkdir(os.path.dirname(publish_path)) frame_start = cmds.playbackOptions(query = True, animationStartTime = True) frame_end = cmds.playbackOptions(query = True, animationEndTime = True) cmds.select(shotCams[0], r = True) #Switching to alembic output for camera. rootList = '' for eachRoot in cmds.ls(sl= True): rootList = '-root %s %s' % (str(cmds.ls(eachRoot, l = True)[0]), rootList) debug(app = None, method = '_publish_nukeCamera_for_item', message = 'rootList: %s' % rootList, verbose = False) abc_export_cmd = "preRollStartFrame -15 -ro -attr SubDivisionMesh -attr smoothed -attr mcAssArchive -wholeFrameGeo -worldSpace -writeVisibility -uvWrite -fr %d %d %s -file %s" % (frame_start, frame_end, rootList, publish_path) cmds.AbcExport(verbose = False, j = abc_export_cmd) ##fm2n.FromMaya2Nuke(exportPath = os.path.dirname(publish_path), nukePath = 'C:\\"Program Files\"\Nuke7.0v6\\', nukeExec = 'Nuke7.0.exe', scriptName = '%s' % shotCams[0], startFrame = startFrame, endFrame = endFrame, camera = shotCams[0]) #fm2n.FromMaya2Nuke(exportPath = os.path.dirname(publish_path), nukePath = '', nukeExec = '', scriptName = '%s' % shotCams[0], startFrame = startFrame, endFrame = endFrame) debug(app = None, method = '_publish_nukeCamera_for_item', message = 'Export Complete...', verbose = False) ## Now register publish with shotgun self._register_publish(publish_path, group_name, sg_task, publish_version, tank_type, comment, thumbnail_path, [primary_publish_path]) debug(app = None, method = '_publish_nukeCamera_for_item', message = '_register_publish complete for %s...' % shotCams[0], verbose = False) print 'Finished camera export for %s...' % shotCams[0] print '=====================' cleanup.turnOnModelEditors() else: cmds.warning('Found more than one shotCam, using the first in the list only!!') pass except Exception, e: raise TankError("Failed to export NukeCamera")
def _write_menu_lst(self, data, path): debug.verbose('writing %s' % path) debug.debug(data) f = open(path, 'w') f.write(data) f.close()
def _publish_renderglobals_xml_for_item(self, item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb): """ Export an xml file for the specified item and publish it to Shotgun. """ group_name = '%s_LIGHTING_RENDERGLOBALS_XML' % ''.join(item["name"].strip("|").split('_hrc')[0].split('_')) debug(app = None, method = '_publish_renderglobals_xml_for_item', message = 'group_name: %s' % group_name, verbose = False) tank_type = output["tank_type"] debug(app = None, method = '_publish_renderglobals_xml_for_item', message = 'tank_type: %s' % tank_type, verbose = False) publish_template = output["publish_template"] debug(app = None, method = '_publish_renderglobals_xml_for_item', message = 'publish_template: %s' % publish_template, verbose = False) # get the current scene path and extract fields from it # using the work template: scene_path = os.path.abspath(cmds.file(query=True, sn= True)) fields = work_template.get_fields(scene_path) publish_version = fields["version"] # update fields with the group name: fields["grp_name"] = group_name ## create the publish path by applying the fields ## with the publish template: publish_path = publish_template.apply_fields(fields) debug(app = None, method = '_publish_renderglobals_xml_for_item', message = 'FINAL publish_path: %s' % publish_path, verbose = False) try: self.parent.log_debug("Executing command: SHADING XML EXPORT PREP!") print '=====================' print 'Exporting the renderglobals xml %s' % publish_path if not os.path.isdir(os.path.dirname(publish_path)): debug(app = None, method = '_publish_renderglobals_xml_for_item', message = 'PATH NOT FOUND.. MAKING DIRS NOW...', verbose = False) os.makedirs(os.path.dirname(publish_path)) ## Now write to xml debug(app = None, method = '_publish_renderglobals_xml_for_item', message = 'writeXML now...', verbose = False) writeXML.writeRenderGlobalData(pathToXML = publish_path) self._register_publish(publish_path, group_name, sg_task, publish_version, tank_type, comment, thumbnail_path, [primary_publish_path]) print 'Finished xml export...' print '=====================' except Exception, e: raise TankError("Failed to export xml")
def run(self): debug("News: UpdateThread") # download cannot contain any tkinter changes self.widget.download()
self.send("atz") # initialize time.sleep(1) self.ELMver = self.get() if self.ELMver is None : self.error("ELMver did not return") return debug("atz response: " + self.ELMver) except Exception, inst: self.error(inst) return self.send("ate0") # echo off debug("ate0 response: " + self.get()) debug("Connected to ECU") self.state = State.Connected def error(self, msg=None): """ called when connection error has been encountered """ debug("Connection Error:", True) if msg is not None: debug(msg, True); if self.port is not None: self.port.close(); self.state = State.Unconnected def get_port_name(self): return str(self.port) if (self.port is not None) else "No Port"
def initiate_paxos(self, v): debug('PAXOS NODE id={}: Initiating Paxos algorithm! Default v={}'. format(self.id, v)) self.P_propose(v)
def resetBox(self, strPathBoxName): "reset the sub tree of one box" debug.debug("INF: choregraphetools.FrameNumber.resetBox( '%s' )" % strPathBoxName) self.animations_FrameNumber[strPathBoxName] = 0
def __init__(self, amentry): self.amentry_id = AddActiveMissionEntry(amentry) debug.debug("New Mission entry: %s (%s)" % (self.amentry_id, amentry.get('MISSION_SHORTDESC', '')))
def P_rx_prepare_response(self, d): # Phase 2a. If the proposer receives a response to its prepare requests # (numbered n) from a majority of acceptors, then it sends an accept # request to each of those acceptors for a proposal numbered n with # a value v, where v is the value of the highest-numbered proposal # among the responses, or is any value if the responses reported no proposals. debug('P{}: rxd prepresp from {} with n={}, p={}'.format( self.id, d['from'], d['n'], d['p'])) n = d['n'] if n not in self.prepare_responses: print( "!!!!!!!!!P{}: Shouldn't happen: Somehow I rxd a repsonse to a prepare-request with an n I didn't send: {}" .format(self.id, d)) self.prepare_responses[n][ d['from']] = d # for this n, remember who voted for what. if len( self.prepare_responses[n] ) > self.MAJORITY: # if we get a majority response for this n, good. debug('P{}: For n={}, I have prepresps from {} > majority={}!'. format(self.id, n, len(self.prepare_responses[n]), self.MAJORITY)) # Fetch the 'real' proposals - the non-None proposals from each prepare response. Also, disallow proposals that propose the value 'None'. # This allows us to get a node up-to-date just by trying to propose the value 'None', without risking reaching consensus # on 'None' if the network has not yet reached consensus. # IOW, a proposal isn't considered if it's None, or if it's non-None but its proposed value is None. proposals = [ r['p'] for r in self.prepare_responses[n].values() if not (r['p'] is None or (r['p'] is not None and r['p'].v is None)) ] if len(proposals) > 0: highest_numbered_proposal = max(proposals) v = highest_numbered_proposal.v debug( 'P{}: Highest-numbered proposal\'s val in prepresps is v={}' .format(self.id, v)) else: debug('P{}: No vals in prepresps, I pick v={}'.format( self.id, self.vdefault)) v = self.vdefault p = Proposal(n, v) for to in self.prepare_responses[n].keys( ): # to each Acceptor I've heard from debug('P{}: txing accept req to A={} with proposal={}'.format( self.id, to, p)) r = { 'from': self.id, 'to': to, 'type': 'accept request', 'p': p } if to == self.id: # my own self-vote self.A_rx_accept_request(r) else: self.send(r)
def LoadLastMission(which=None): """ Makes a mission an active mission. """ print("#given mission argument: ", which) plr = getMissionPlayer() if which is None: which = str(players[plr].lastMission) print("#loading mission: ", which) if VS.networked(): custom.run('mission_lib', ['LoadLastMission', which], None) return last_constructor = players[plr].last_constructor last_args = players[plr].last_args last_briefing_vars = players[plr].last_briefing_vars last_briefing = players[plr].last_briefing ret = True if which in last_constructor and which in last_args: if last_constructor[which] == None: if type(last_args[which]) == str: script = "%(args)s" else: script = "%(args)r()" vars = dict(args=last_args[which]) else: script = '''# import %(constructor)s temp=%(constructor)s.%(constructor)s%(args)s mission_lib.AddMissionHooks(temp) temp=0 ''' cons = last_constructor[which] if type(cons) != str: cons = cons.__name__ if type(last_args[which]) == str: args = last_args[which] else: args = repr(last_args[which]) vars = dict(constructor=cons, args=args) script = script % vars if script[:1] == '#': prescript = '''# import mission_lib mission_lib.SetMissionHookArgs(%(amentry)r) %(postscript)s''' amentry = last_briefing_vars[0].get(which, dict()) try: amentry.update( iter(last_briefing_vars[1].get(which, dict()).items())) amentry.update([ #('MISSION_NAME',which), ('DESCRIPTION', last_briefing[0].get(which, '')), ('ACCEPT_MESSAGE', last_briefing[1].get(which, '')) ]) except: debug.error("TRACING BACK") import sys debug.error(sys.exc_info()[0]) debug.error(sys.exc_info()[1]) debug.error("BACKTRACE done") ret = False vars = dict(amentry=amentry, postscript=script) script = prescript % vars debug.debug("Loading mission:\n%s" % script) VS.LoadNamedMissionScript(which, script) else: debug.debug('No last mission with name "' + str(which) + '"') ret = False RemoveLastMission(which) return ret
def commander(c, genList, circleList, starList): # this function opens the commands.txt file and converts it into a list of # commands on how to play the level accompanying the song and put them into # a list. If a command is unrecognized, the game will close (for now). # It will take the commands and their parameters and organize them into a # 2D list # RETURNS: A list of lists # DEFAULT VALUES try: genFile = open(genList, 'r') except pygame.error: debug(c.DEBUG, ('Cannot open file: ', genList)) raise SystemExit(str(geterror())) try: circleFile = open(circleList, 'r') except pygame.error: debug(c.DEBUG, ('Cannot open file: ', circleList)) raise SystemExit(str(geterror())) try: starFile = open(starList, 'r') except pygame.error: debug(c.DEBUG, ('Cannot open file: ', starList)) raise SystemExit(str(geterror())) # list of general commands genCommands = genFile.read() genCommands = genCommands.split() genCommandList = [] # list of circle commands circleCommands = circleFile.read() circleCommands = circleCommands.split() circleCommandList = [] # list of star commands starCommands = starFile.read() starCommands = starCommands.split() starCommandList = [] for action in genCommands: # the action[0] just checks the first letter in the action. # Option 1: set the BPM if action[0] == 'B': try: bpm = action.replace('BPM', '') bpm = float(bpm) except Exception: print "Invalid BPM possible. See commands.txt" sys.exit(UserWarning) # calculate the global wait times. # (how many frames until the next action is committed.) cWait = c.FPS / (bpm / 60.0) fWait = cWait # calculate the move speed of circle and star # this equation sets the speed as a fraction of the radius of the # ring, so that it takes X seconds to reach the ring. # the X seconds will either be user defined, or bpm/60 # (how quickly an action is completed) cSpeed = (c.RING_SIZE / c.FPS) * (bpm / 60.0) fSpeed = (c.RING_RADIUS / c.FPS) * (bpm / 60.0) # the BPM list is formatted as such:'B', WC, WF, CSP, and FSP genCommandList.append(['B', cWait, fWait, cSpeed, fSpeed]) #======================================================================= # elif action[0] == 'P': # if action == 'Play:': # commandList.append(['P']) # else: # print "Invalid Play action given. See commands.txt" # sys.exit(UserWarning) #======================================================================= elif action[0] == 'J': if "JumpTo," in action: try: startTime = float(action.replace('JumpTo,', '')) except Exception: print "Invalid start time given. Must be in seconds. See commands.txt" sys.exit(UserWarning) genCommandList.append(['J', startTime]) else: print "Invalid start time given. Must be 'JumpTo,X'. See commands.txt" sys.exit(UserWarning) elif action[0] == 'W': if action[1] == 'G': # a global constant wait time between each action gWait = action.replace('W', '') gWait = gWait.replace('G', '') try: gWait = c.FPS * float(gWait) except Exception: print "Invalid WG# given. See commands.txt" sys.exit(UserWarning) genCommandList.append(['WG', gWait]) elif action[1] == 'C': # a global constant wait time before each circle creation cWait = action.replace('W', '') cWait = cWait.replace('C', '') try: cWait = c.FPS * float(cWait) except Exception: print "Invalid WC# given. See commands.txt" sys.exit(UserWarning) genCommandList.append(['WC', cWait]) elif action[1] == 'F': # a global constant wait time before each star creation fWait = action.replace('W', '') fWait = fWait.replace('F', '') try: fWait = c.FPS * float(fWait) except Exception: print "Invalid WF# given. See commands.txt" sys.exit(UserWarning) genCommandList.append(['WF', fWait]) for action in circleCommands: if action[0] == 'C': color = '' # we test to see if the action is for changing speed, or making circ if action[1] == 'S': try: cSpeed = action.replace('CSP', '') cSpeed = float(cSpeed) cSpeed = (c.RING_SIZE / c.FPS) / cSpeed debug(c.DEBUG, cSpeed) except Exception: print "Invalid CSP given. See commands.txt" sys.exit(UserWarning) circleCommandList.append(['CS', cSpeed]) # if it does not begin with CS, that means it is for making a circle else: cSpeed = action.replace('C', '') cSpeed = cSpeed.replace(',', '') # now we iterate through the string, creating a color variable # and remove the letters, leaving speed with only numbers. # if no speed was given, then the len will be 0, so we can exit. while len(cSpeed) != 0 and cSpeed[0].isalpha(): debug(c.DEBUG, ('cSpeed2: ', cSpeed)) color = color + cSpeed[0] cSpeed = cSpeed.replace(cSpeed[0], '') # if anything is left in the variable cSpeed, then it SHOULD be # the circle speed number if len(cSpeed) != 0: try: cSpeed = float(cSpeed) cSpeed = (c.RING_SIZE / c.FPS) / cSpeed except Exception: print "Invalid CSpeed given. See commands.txt" sys.exit(UserWarning) # grab the right colors! R, G, B = 0, 0, 0 debug(c.DEBUG, ("COLOR: ", color)) if color.find('R') != -1: R = 255 if color.find('G') != -1: G = 255 if color.find('B') != -1: B = 255 if (R, G, B) == (0, 0, 0): print "No colors found. See commands.txt" sys.exit(UserWarning) circleCommandList.append(['C', (R, G, B), cSpeed]) elif action[0] == 'W': if action[1] == 'C': # a global constant wait time before each circle creation cWait = action.replace('W', '') cWait = cWait.replace('C', '') try: cWait = c.FPS * float(cWait) except Exception: print "Invalid WC# given. See commands.txt" sys.exit(UserWarning) circleCommandList.append(['WC', cWait]) elif action[1].isdigit(): waitTime = action.replace('W', '') # an instance wait, for only that call. try: # how many frames before the next action occurs waitTime = c.FPS * float(waitTime) except Exception: print "Invalid W# given. See commands.txt" sys.exit(UserWarning) circleCommandList.append(['W', waitTime]) elif action[0] == ':': if action == ':Stop': circleCommandList.append(['S']) else: print "Invalid Stop given. See commands.txt" sys.exit(UserWarning) for action in starCommands: if action[0] == 'F': # we test to see if the action is for changing speed, or making star if action[1] == 'S': try: fSpeed = action.replace('FSP', '') fSpeed = float(fSpeed) fSpeed = (c.RING_RADIUS / c.FPS) / fSpeed except Exception: print "Invalid FSP given. See commands.txt" sys.exit(UserWarning) starCommandList.append(['FS', fSpeed]) else: if action.find(',') != -1: # if both an angle and speed is defined, we must split the # numbers by the comma. starTemp = action.replace('F', '') fAngle, fSpeed = starTemp.split(',') try: fAngle = float(fAngle) fSpeed = float(fSpeed) fSpeed = (c.RING_RADIUS / c.FPS) / fSpeed except Exception: print "Invalid Fx/# given. See commands.txt" sys.exit(UserWarning) starCommandList.append(['F', fAngle, fSpeed]) else: fAngle = action.replace('F', '') try: fAngle = float(fAngle) except Exception: print "Invalid Fx given. See commands.txt" sys.exit(UserWarning) starCommandList.append(['F', fAngle, '']) elif action[0] == 'W': if action[1].isdigit(): waitTime = action.replace('W', '') # an instance wait, for only that call. try: # how many frames before the next action occurs waitTime = c.FPS * float(waitTime) except Exception: print "Invalid W# given. See commands.txt" sys.exit(UserWarning) starCommandList.append(['W', waitTime]) elif action[1] == 'F': # a global constant wait time before each star creation fWait = action.replace('W', '') fWait = fWait.replace('F', '') try: fWait = c.FPS * float(fWait) except Exception: print "Invalid WF# given. See commands.txt" sys.exit(UserWarning) starCommandList.append(['WF', fWait]) elif action[1].isdigit(): waitTime = action.replace('W', '') # an instance wait, for only that call. try: # how many frames before the next action occurs waitTime = c.FPS * float(waitTime) except Exception: print "Invalid W# given. See commands.txt" sys.exit(UserWarning) starCommandList.append(['W', waitTime]) elif action[0] == ':': if action == ':Stop': starCommandList.append(['S']) else: print "Invalid Stop given. See commands.txt" sys.exit(UserWarning) debug(c.DEBUG, (genCommandList, circleCommandList, starCommandList)) return genCommandList, circleCommandList, starCommandList