def __init__(self, engine, mic): Task.__init__(self) self.engine = engine self.channel = None self.mic = mic self.playing = False self.volume = 1.0
def __init__(self, goal): Task.__init__(self) self.goal = goal self.path_request = None self.path = deque() self.stuck = False self.update = self.__request_path
def __init__(self, name, **kwds): Task.__init__(self) self._name = name self._input_list = [] self._output_list = [] self._message_list = [] # Optional arguments. if 'version' in kwds: self.version = kwds['version'] # Update default user number. if self.userno == -1: self.userno = AIPS.userno # See if there is a proxy that can hand us the details for # this task. params = None for proxy in AIPS.proxies: try: inst = getattr(proxy, self.__class__.__name__) params = inst.params(name, self.version) except Exception, exception: if AIPS.debuglog: print >>AIPS.debuglog, exception continue break
def __init__(self): Task.__init__(self) self.mouse = pygame.mouse self.mouseListeners = [] self.keyListeners = [] self.systemListeners = [] self.priorityKeyListeners = [] self.controls = Controls() self.disableKeyRepeat() # Initialize joysticks pygame.joystick.init() self.joystickAxes = {} self.joystickHats = {} self.joysticks = [pygame.joystick.Joystick(id) for id in range(pygame.joystick.get_count())] for j in self.joysticks: j.init() self.joystickAxes[j.get_id()] = [0] * j.get_numaxes() self.joystickHats[j.get_id()] = [(0, 0)] * j.get_numhats() Log.debug("%d joysticks found." % (len(self.joysticks))) # Enable music events Audio.Music.setEndEvent(MusicFinished) # Custom key names self.getSystemKeyName = pygame.key.name pygame.key.name = self.getKeyName
def __init__(self): self.logClassInits = Config.get("game", "log_class_inits") if self.logClassInits == 1: Log.debug("Input class init (Input.py)...") Task.__init__(self) self.mouse = pygame.mouse self.mouseListeners = [] self.keyListeners = [] self.systemListeners = [] self.priorityKeyListeners = [] self.controls = Controls() self.disableKeyRepeat() # Initialize joysticks pygame.joystick.init() self.joystickAxes = {} self.joystickHats = {} self.joysticks = [pygame.joystick.Joystick(id) for id in range(pygame.joystick.get_count())] for j in self.joysticks: j.init() self.joystickAxes[j.get_id()] = [0] * j.get_numaxes() self.joystickHats[j.get_id()] = [(0, 0)] * j.get_numhats() Log.debug("%d joysticks found." % (len(self.joysticks))) # Enable music events Audio.Music.setEndEvent(MusicFinished) # Custom key names self.getSystemKeyName = pygame.key.name pygame.key.name = self.getKeyName
def __init__(self, engine, controlnum, samprate=44100): Task.__init__(self) self.engine = engine self.controlnum = controlnum devnum = self.engine.input.controls.micDevice[controlnum] if devnum == -1: devnum = None self.devname = pa.get_default_input_device_info()['name'] else: self.devname = pa.get_device_info_by_index(devnum)['name'] self.mic = pa.open(samprate, 1, pyaudio.paFloat32, input=True, input_device_index=devnum, start=False) if Config.get('game', 'use_new_pitch_analyzer') or not have_pypitch: self.analyzer = Analyzer(samprate) else: self.analyzer = pypitch.Analyzer(samprate) self.mic_started = False self.lastPeak = 0 self.detectTaps = True self.tapStatus = False self.tapThreshold = -self.engine.input.controls.micTapSensitivity[controlnum] self.passthroughQueue = [] passthroughVolume = self.engine.input.controls.micPassthroughVolume[controlnum] if passthroughVolume > 0.0: Log.debug('Microphone: creating passthrough stream at %d%% volume' % round(passthroughVolume * 100)) self.passthroughStream = Audio.MicrophonePassthroughStream(engine, self) self.passthroughStream.setVolume(passthroughVolume) else: Log.debug('Microphone: not creating passthrough stream') self.passthroughStream = None
def __init__(self, server, command): Task.__init__(self) self.server= server self.command=command self.name="ExecuteRemoteWinCommandTask" self.description= "this task is used to execute command on remote machine through rpyc" self.stat=TaskStatus.RUNNING
def __init__(self, machinename, localfile, remotefile): Task.__init__(self) self.name="DownloadFileTask" self.description="This task is used to download file from rpyc server" self.stat=TaskStatus.RUNNING self.machinename=machinename self.localfile=localfile self.remotefile=remotefile
def __init__(self, tasks): Task.__init__(self, 0, "Bundle-", 0, 0, 0, []) self.tasks = tasks # The Tasks in the bundle. self.TasksMap = {} # Mappings of tasks to days. self.SkillsMap = {} # Mappings of skill hours to days. self.contents = [] # IDs of the tasks in the bundle. self.initialize(tasks) self.calculateDays(tasks) self.allocate() self.distribute(tasks)
def __init__(self, name, **kwds): """ Create AIPS task object Creates task object and calls server function to parse the task help and POPSDAT.HLP files to obtain task specific parametrs and documentation. Following is a list of class members: _default_dict = Dictionary with default values of parameters _input_list = List of input parameters in order _output_list = List of output parameters in order _min_dict = Parameter minimum values as a List _max_dict = Parameter maximum values as a List _hlp_dict = Parameter descriptions (list of strings) as a dictionary _strlen_dict = String parameter lengths as dictionary _help_string = Task Help documentation as list of strings _explain_string = Task Explain documentation as list of strings _short_help = One line description of task _message_list = list of execution messages Current parameter values are given as class members. """ if not self._task_type: self._task_type = 'AIPS' Task.__init__(self) self._name = name self._input_list = [] self._output_list = [] self._message_list = [] self._remainder = "" # Partial message buffer # Optional arguments. if 'version' in kwds: self.version = kwds['version'] else: if 'AIPS_VERSION' in os.environ: self.version = os.environ["AIPS_VERSION"] # Update default user number. if self.__class__.userno == 0: self.__class__.userno = AIPS.userno # See if there is a proxy that can hand us the details for # this task. params = None for proxy in AIPS.proxies: try: inst = getattr(proxy, self.__class__.__name__) params = inst.params(name, self.version) except Exception, exception: print exception if AIPS.debuglog: print >>AIPS.debuglog, exception continue break
def __init__(self, engine, channel, fileName): Task.__init__(self) self.engine = engine self.fileName = fileName self.channel = channel.channel self.playing = False self.bufferSize = 1024 * 64 self.bufferCount = 8 self.volume = 1.0 self.buffer = numpy.zeros((2 * self.bufferSize, 2), dtype = numpy.int16) self.decodingRate = 4 self._reset()
def __init__(self, engine, channel, fileName): Task.__init__(self) self.engine = engine self.fileName = fileName self.channel = channel.channel self.playing = False self.bufferSize = 1024 * 64 self.bufferCount = 8 self.volume = 1.0 self.buffer = Numeric.zeros((2 * self.bufferSize, 2), typecode="s") self.decodingRate = 4 self._reset()
def __init__(self, engine, geometry=None): Task.__init__(self) self.layers = [] self.incoming = [] self.outgoing = [] self.visibility = {} self.transitionTime = 512.0 self.geometry = geometry or glGetIntegerv(GL_VIEWPORT) self.savedGeometry = None self.engine = engine w = self.geometry[2] - self.geometry[0] h = self.geometry[3] - self.geometry[1] self.aspectRatio = float(w) / float(h)
def __init__(self, engine, geometry = None): Task.__init__(self) self.layers = [] self.incoming = [] self.outgoing = [] self.visibility = {} self.transitionTime = 512.0 self.geometry = geometry or glGetIntegerv(GL_VIEWPORT) self.savedGeometry = None self.engine = engine w = self.geometry[2] - self.geometry[0] h = self.geometry[3] - self.geometry[1] self.aspectRatio = float(w) / float(h)
def __init__(self): Task.__init__(self) # Task settings self.allowMissing = False self.limitTrainingToAnnotated = True # Data files self.sequencesPath = "Swiss_Prot/Swissprot_sequence.tsv.gz" self.targetsPath = "CAFA3_targets/Target_files/target.all.fasta" self.annotationsPath = "data/Swissprot_propagated.tsv.gz" self.splitPath = "data" self.foldsPath = "folds/training_folds_170125.tsv.gz" self.termsPath = "GO/go_terms.tsv" # Feature settings self.features = { "taxonomy": TaxonomyFeatureBuilder(["Taxonomy"]), "similar": UniprotFeatureBuilder("Uniprot/similar.txt"), "blast": BlastFeatureBuilder( ["temp_blastp_result_features", "blastp_result_features"]), "blast62": BlastFeatureBuilder( ["CAFA2/training_features", "CAFA2/CAFA3_features"], tag="BLAST62"), "delta": BlastFeatureBuilder([ "temp_deltablast_result_features", "deltablast_result_features" ], tag="DELTA"), "interpro": InterProScanFeatureBuilder([ "temp_interproscan_result_features", "interproscan_result_features" ]), "predgpi": PredGPIFeatureBuilder(["predGPI"]), "nucpred": NucPredFeatureBuilder(["nucPred"]), "netacet": NetAcetFeatureBuilder(["NetAcet"]), "funtaxis": FunTaxISFeatureBuilder(["FunTaxIS"]), "ngrams": NGramFeatureBuilder( ["ngrams/4jari/min_len3-min_freq2-min1fun-top_fun5k"]) } self.defaultFeatures = [ "taxonomy", "blast", "delta", "interpro", "predgpi" ]
def __init__(self, engine, channel, fileName): Task.__init__(self) self.engine = engine self.fileName = fileName self.channel = channel self.playing = False self.bufferSize = 1024 * 64 self.bufferCount = 8 self.volume = 1.0 #myfingershurt: buffer is 2D array (one D for each channel) of 16-bit UNSIGNED integers / samples # 2*1024*64 = 131072 samples per channel self.buffer = zeros((2 * self.bufferSize, 2)) self.decodingRate = 4 self._reset()
def __init__(self): Task.__init__(self) # Task settings self.remapSets = {"test": "devel"} self.allowMissing = True self.limitTrainingToAnnotated = False # Data files self.sequencesPath = "CAFA_PI/Swissprot/CAFA_PI_Swissprot_sequence.tsv.gz" self.targetsPath = "CAFA_PI/Swissprot/target.all.fasta.gz" self.annotationsPath = "CAFA_PI/Swissprot/CAFA_PI_Swissprot_propagated.tsv.gz" self.splitPath = "CAFA_PI/Swissprot" self.foldsPath = "folds/CAFA_PI_training_folds_180417.tsv.gz" self.termsPath = "GO/go_terms.tsv" # Feature settings self.features = { "taxonomy": TaxonomyFeatureBuilder(["CAFA_PI/features/Taxonomy"]), "blast": BlastFeatureBuilder([ "CAFA_PI/features/temp_blastp_result_features", "CAFA_PI/features/blastp_result_features" ]), "blast62": BlastFeatureBuilder([ "CAFA_PI/features/CAFA2/training_features", "CAFA_PI/features/CAFA2/CAFA3_features" ], tag="BLAST62"), "delta": BlastFeatureBuilder([ "CAFA_PI/features/temp_deltablast_result_features", "CAFA_PI/features/deltablast_result_features" ], tag="DELTA"), "interpro": InterProScanFeatureBuilder([ "CAFA_PI/features/temp_interproscan_result_features", "CAFA_PI/features/interproscan_result_features" ]), "predgpi": PredGPIFeatureBuilder(["CAFA_PI/features/predGPI"]), "nucpred": NucPredFeatureBuilder(["CAFA_PI/features/nucPred"]), "netacet": NetAcetFeatureBuilder(["CAFA_PI/features/NetAcet"]) } self.defaultFeatures = ["all"]
def __init__(self, fileName,engine,speed = 1): Task.__init__(self) if not engine: engine = GameEngine.getEngine() self.engine = engine self.fileName = fileName self.channel = None self.playing = False self.bufferSize = 1024 * 64 self.bufferCount = 8 self.volume = 1.0 self.event = None self.speed = speed #myfingershurt: buffer is 2D array (one D for each channel) of 16-bit UNSIGNED integers / samples # 2*1024*64 = 131072 samples per channel self.buffer = np.zeros((2 * self.bufferSize, 2),dtype=np.int16) self.decodingRate = 4 self._reset()
def __init__(self, engine, geometry = None, screens = 1): Task.__init__(self) self.layers = [] self.incoming = [] self.outgoing = [] self.visibility = {} self.transitionTime = 512.0 self.engine = engine if geometry: self.geometry = list(geometry) else: self.geometry = list(glGetIntegerv(GL_VIEWPORT)) w = self.geometry[2] - self.geometry[0] h = self.geometry[3] - self.geometry[1] self.aspectRatio = float(w) / float(h) self.geometryNormalized = [0,0,0,0] self.setNormalizedGeometry() self.geometryAll = None self.initGeometryAll() self.geometryAllHalf = None self.initGeometryAllHalf()
def __init__(self, engine, controlnum, samprate=44100): Task.__init__(self) self.engine = engine self.controlnum = controlnum devnum = self.engine.input.controls.micDevice[controlnum] if devnum == -1: devnum = None self.devname = pa.get_default_input_device_info()['name'] else: self.devname = pa.get_device_info_by_index(devnum)['name'] self.mic = pa.open(samprate, 1, pyaudio.paFloat32, input=True, input_device_index=devnum, start=False) if Config.get('game', 'use_new_pitch_analyzer') or not have_pypitch: self.analyzer = Analyzer(samprate) else: self.analyzer = pypitch.Analyzer(samprate) self.mic_started = False self.lastPeak = 0 self.detectTaps = True self.tapStatus = False self.tapThreshold = -self.engine.input.controls.micTapSensitivity[ controlnum] self.passthroughQueue = [] passthroughVolume = self.engine.input.controls.micPassthroughVolume[ controlnum] if passthroughVolume > 0.0: Log.debug( 'Microphone: creating passthrough stream at %d%% volume' % round(passthroughVolume * 100)) self.passthroughStream = Audio.MicrophonePassthroughStream( engine, self) self.passthroughStream.setVolume(passthroughVolume) else: Log.debug('Microphone: not creating passthrough stream') self.passthroughStream = None
def __init__(self): Task.__init__(self)
def __init__(self, channels=8): Task.__init__(self) self.eventLoop = pyglet.app.EventLoop() self.channels = [Channel(i) for i in range(channels)]
def __init__(self): Task.__init__(self) self.name="CreateLinuxDSNTask" self.description="this task is used to Configue the DSN on Linux machine." self.stat = self.RUNNING self.info = "create DSN task is running"
def __init__(self): Task.__init__(self) self.name="SimulaterLinuxServer" self.description="this task is used to Simulate Linux server" self.stat = self.RUNNING self.info = "start Simulate server"
def __init__(self, env, id, frame_h= SimParams.FRAME_DEFAULT_H, \ frame_w = SimParams.FRAME_DEFAULT_W, \ frame_rate = SimParams.FRAME_RATE, \ frame_type = "I", \ frame_ix_in_gop = 0, \ unique_gop_id = 0, \ gop_id = 0, \ gop_struct = SimParams.GOP_STRUCTURE, \ video_stream_id = None, \ wf_id = None, \ priority = None, ## optional params ## calc_deps = True, calc_cc = True, calc_pri = True ): ## pass params to parent class Task.__init__(self, env, "MPGFrame-" + frame_type, id, None, None, None, None, None, priority, env.now) ## gop-level self.parent_gop_id = gop_id # same sequence of gops in two videos may have same same GOP number self.unique_gop_id = unique_gop_id ## frame level self.frame_h = frame_h self.frame_w = frame_w self.frame_rate = frame_rate self.frame_type = frame_type self.frame_num_pixels = (self.frame_h * self.frame_w) self.frame_ix_in_gop = frame_ix_in_gop if (calc_pri == True): self.frame_priority = self.calc_FramePriorityInsideGOP( self.frame_ix_in_gop) # according to isovic and fohler #self.priority = priority ## gop-level self.gop_structure = gop_struct self.period = float( float(len(self.gop_structure)) * float(1.0 / float(self.frame_rate))) ## video-level self.video_stream_id = video_stream_id self.wf_id = wf_id self.video_genre = None self.IsHeadVideoGop = False # is this frame in the first video stream GOP self.IsTailVideoGop = False # is this frame in the last video stream GOP # platform level self.dispatched_ibuffid = None if (calc_deps == True): # which other frames/tasks do I need to complete this task ? self.frame_dependencies = self.calc_FrameDependencies( self.frame_ix_in_gop, self.id)['dep_gop_frames_ixs'] self.set_dependencies( self.calc_FrameDependencies( self.frame_ix_in_gop, self.id)['dep_task_ids']) # dependent tasks # which other frame/task needs this task once it's completed ? # when task is finished these dep-pointers will be used to send the # completed task to the other cores # Note : these only track task_ids self.which_frames_needs_me = self.calc_FrameDependencies( self.frame_ix_in_gop, self.id)['which_frame_needs_current_frame'] self.which_tasks_needs_me = self.calc_FrameDependencies( self.frame_ix_in_gop, self.id)['which_task_needs_current_task'] self.my_closest_children = self.calc_FrameDependencies( self.frame_ix_in_gop, self.id)['my_closest_children'] self.my_closest_parent = self.calc_FrameDependencies( self.frame_ix_in_gop, self.id)['my_closest_parent'] self.non_dep_frames = self.calc_FrameDependencies( self.frame_ix_in_gop, self.id)['non_dep_frames'] self.possible_interfering_frame = self.calc_FrameDependencies( self.frame_ix_in_gop, self.id)['possible_interfering_frames'] if (calc_cc == True): ## block level specs self.block_h = 8 self.block_w = 8 #self.B_max = int(round((self.frame_h * self.frame_w) / (self.block_h * self.block_w))) # max blocks per frame self.B_max = int( round( float(self.frame_h * self.frame_w) / float( self.block_h * self.block_w))) # max blocks per frame self.B_min = 0 # at least 1 block per frame ? ## block level timing specs (in ms) # refer to : # [1]Y. Tan, P. Malani, Q. Qiu, and QingWu, # 'Workload prediction and dynamic voltage scaling for MPEG decoding,' # in Asia and South Pacific Conference on Design Automation, 2006, # [2]P. Malani, Y. Tan, and Q. Qiu, # 'Resource-aware High Performance Scheduling for Embedded MPSoCs With the Application of MPEG Decoding,' # in 2007 IEEE International Conference on Multimedia and Expo, 2007 self.M1_t = float( SimParams.MPEG_BLOCK_M1_T * SimParams.CPU_EXEC_SPEED_RATIO) # used in : I, P, B self.M2_t = float(SimParams.MPEG_BLOCK_M2_T * SimParams.CPU_EXEC_SPEED_RATIO) # used in : P self.M3_t = float(SimParams.MPEG_BLOCK_M3_T * SimParams.CPU_EXEC_SPEED_RATIO) # used in : P self.M4_t = float(SimParams.MPEG_BLOCK_M4_T * SimParams.CPU_EXEC_SPEED_RATIO) # used in : B self.M5_t = float(SimParams.MPEG_BLOCK_M5_T * SimParams.CPU_EXEC_SPEED_RATIO) # used in : B self.M6_t = float(SimParams.MPEG_BLOCK_M6_T * SimParams.CPU_EXEC_SPEED_RATIO) # used in : B self.M7_t = float(SimParams.MPEG_BLOCK_M7_T * SimParams.CPU_EXEC_SPEED_RATIO) # used in : B self.M8_t = float(SimParams.MPEG_BLOCK_M8_T * SimParams.CPU_EXEC_SPEED_RATIO) # used in : P, B self.M9_t = float( SimParams.MPEG_BLOCK_M9_T * SimParams.CPU_EXEC_SPEED_RATIO ) # Run-length coding time : propotional to frame size self.M10_t = float( SimParams.MPEG_BLOCK_M10_T * SimParams.CPU_EXEC_SPEED_RATIO ) # constant : used when generating the linear regression model ## task level rts specs - need to calculate cc = self.calc_FrameComputationTime(self.frame_type) self.set_computationCost(cc) self.set_remainingComputationCost(cc) ## deadline calculation dl = (1.0 / self.frame_rate) self.set_deadline(dl) # this will be adjusted later self.end_to_end_deadline = (float(len(self.gop_structure)) / float(self.frame_rate)) max_mem = ( (self.frame_h * self.frame_w) * 16 ) / 8 # 16 bit, rgb, assume I_size = P_size = B_size (in bytes) ) self.set_maxMemConsumption(max_mem) self.set_timeLeftTillCompletion(cc) self.set_timeLeftTillDeadline(dl) self.absDeadline = None self.completedTaskSize = max_mem # worst case execution times of different types of frames - stored for later use self.wccIFrame = None self.wccPFrame = None self.wccBFrame = None # avg case execution times of different types of frames - stored for later use self.avgccIFrame = None self.avgccPFrame = None self.avgccBFrame = None # time which all deps of the tasks were complete and available self.deps_allcomplete_time = None # relative subtask deadline self.relative_deadline = None # analytical wcet/wcrt self.analytical_wcet = None self.analytical_wcrt_with_deps = None # task size self.mpeg_tasksize = self.calc_encoded_mpegframe_size()
def __init__(self, name, **kwds): Task.__init__(self) self._name = name self._input_list = [] self._output_list = [] self._message_list = [] # Optional arguments. if 'version' in kwds: self.version = kwds['version'] # Update default user number. if self.userno == -1: self.userno = AIPS.userno # See if there is a proxy that can hand us the details for # this task. params = None for proxy in AIPS.proxies: try: inst = getattr(proxy, self.__class__.__name__) params = inst.params(name, self.version) except Exception as exception: if AIPS.debuglog: print(exception, file=AIPS.debuglog) continue break if not params: msg = "%s task '%s' is not available" % (self._package, name) raise RuntimeError(msg) # The XML-RPC proxy will return the details as a dictionary, # not a class. self._default_dict = params['default_dict'] self._input_list = params['input_list'] self._output_list = params['output_list'] self._min_dict = params['min_dict'] self._max_dict = params['max_dict'] self._strlen_dict = params['strlen_dict'] self._help_string = params['help_string'] self._explain_string = params['explain_string'] for adverb in self._default_dict: if type(self._default_dict[adverb]) == list: value = self._default_dict[adverb] self._default_dict[adverb] = List(self, adverb, value) # Initialize all adverbs to their default values. self.defaults() # The maximum value for disk numbers is system-dependent. for name in self._disk_adverbs: if name in self._max_dict: self._max_dict[name] = float(len(AIPS.disks) - 1) pass continue # The maximum channel is system-dependent. for name in self._chan_adverbs: if name in self._max_dict: # Assume the default self._max_dict[name] = 16384.0 pass continue # The maximum image size is system-dependent. for name in self._box_adverbs: if name in self._max_dict: # Assume the default self._max_dict[name] = 32768.0 pass continue return # __init__
def __init__(self, name, **kwds): """ Create ObitScript task object Creates Script Object. name = name of script object Optional Keywords: script = Script to execute as string or list of strings file = Name of text file containing script URL = URL on which the script is to be executed Default = None = local execution AIPSDirs = List of AIPS directories on URL Default = current AIPS directories on url FITSDirs = List of FITS directories on URL Default = current FITS directories on url AIPSUser = AIPS user number for AIPS data files Default is current version = AIPS version string, Default = current Following is a list of class members: url = URL of execution server, None=Local proxy = Proxy for URL script = Script as text string userno = AIPS user number AIPSDirs = List of AIPS directories on URL FITSDirs = List of FITS directories on URL AIPSUser = AIPS user number for AIPS data files version = AIPS version string _message_list = messages from Script execution """ Task.__init__(self) self._name = name self.url = None # URL - local self.proxy = LocalProxy # proxy self._message_list = [] self.AIPSDirs = [] self.FITSDirs = [] self.script = [] self._remainder = "" # Partial message buffer # Optional arguments. if 'URL' in kwds: self.url = kwds['URL'] self.proxy = ServerProxy(self.url) elif 'url' in kwds: self.url = kwds['url'] self.proxy = ServerProxy(self.url) else: self.url = None self.proxy = LocalProxy # AIPS directories on target host self.AIPSDirs = [] if 'AIPSDirs' in kwds: for x in kwds['AIPSDirs']: self.AIPSDirs.append(x) else: # Current disks on self.url for x in AIPS.disks: if x != None and x.url == self.url: self.AIPSDirs.append(x.dirname) # FITS directories on target host self.FITSDirs = [] if 'FITSDirs' in kwds: for x in kwds['FITSDirs']: self.FITSDirs.append(x) else: # Current disks on self.url for x in FITS.disks: if x != None and x.url == self.url: self.FITSDirs.append(x.dirname) if 'AIPSUser' in kwds: self.userno = kwds['AIPSUser'] else: self.userno = AIPS.userno # Script given if 'script' in kwds: scr = kwds['script'] if type(scr) == list: # List of strings self.script = scr else: # Simple string self.script.append(scr) # File name given if 'file' in kwds: input = open(kwds['file']) line = " " while (line): line = input.readline() # read next line if not line: # EOF? break self.script.append(line) input.close() # Update default user number. if self.__class__.userno == 0: self.__class__.userno = AIPS.userno return # __init__
def __init__(self, id, name, desc, date, duration, startTask, finalTasks, pred, succ, children, resources, deliverables): Task.__init__(self, id, name, desc, date, duration, pred, succ, resources, deliverables) self.children = children self.startTask = startTask self.finalTasks = finalTasks
def __init__(self): Task.__init__(self) self.name="MonitorLinuxServer" self.description="this task is used to monitor Linux server" self.stat = self.RUNNING self.info = "start monitor server task is running"
def __init__(self): Task.__init__(self) self.name = "ConfigLinuxDiagTask" self.description = "this task is used to configure the performance counter and log size" self.stat = self.RUNNING self.info = "configure the diag task is running"
def __init__(self, env, id, frame_h= 1152, frame_w = 1440, frame_rate = 25, gop_size = SimParams.GOP_LENGTH , \ gop_struct = SimParams.GOP_STRUCTURE, priority = 1, seed = time.time()): ## pass params to parent class Task.__init__(self, env, "MPEG2GOPTask", id, None, None, None, None, None, priority) ## frame level self.frame_h = frame_h self.frame_w = frame_w self.frame_rate = frame_rate ## gop specific self.gop_length = gop_size self.gop_struct = gop_struct self.gop_size_bytes = self.gop_length * (self.frame_h * self.frame_w) ## block level specs self.block_h = 8 self.block_w = 8 self.B_max = int( round((self.frame_h * self.frame_w) / (self.block_h * self.block_w))) # max blocks per frame self.B_min = 1 # at least 1 block per frame ## block level timing specs (in ms) # refer to : # [1]Y. Tan, P. Malani, Q. Qiu, and QingWu, # 'Workload prediction and dynamic voltage scaling for MPEG decoding,' # in Asia and South Pacific Conference on Design Automation, 2006, # [2]P. Malani, Y. Tan, and Q. Qiu, # 'Resource-aware High Performance Scheduling for Embedded MPSoCs With the Application of MPEG Decoding,' # in 2007 IEEE International Conference on Multimedia and Expo, 2007 self.M1_t = 0.000050 self.M2_t = 0.000002 self.M3_t = 0.000001 self.M4_t = 0.000005 self.M5_t = 0.000009 self.M6_t = 0.000006 self.M7_t = 0.000003 self.M8_t = 0.000001 self.M9_t = 0.000015 # Run-length coding time : propotional to frame size ## task level rts specs - need to calculate cc = self.calc_GOPComputationTime() self.set_computationCost(cc) dl = float(self.gop_length) * (1.0 / self.frame_rate) #print float(self.gop_length) * (1.0/self.frame_rate) self.set_deadline(dl) max_mem = ( ((self.frame_h * self.frame_w) * self.gop_length) * (16) / 8 ) # 16 bit, rgb, assume I_size = P_size = B_size # in bytes ) self.set_maxMemConsumption(max_mem) self.set_timeLeftTillCompletion(cc) self.set_timeLeftTillDeadline(dl) ## randomiser specific self._gop_rand_seed = seed + self.id
def __init__(self): Task.__init__(self) self.name="installtomcatwebonLinux" self.description="this task is used to install tomcat web on Linux" self.stat = self.RUNNING self.info = "this task is used to install tomcat web on Linux"
def __init__(self): Task.__init__(self) self.name="ConfigUnixIServerTask" self.description="this task is used to configure iServer on Unix machine" self.info="configure Linux iserver is started"
def __init__(self): Task.__init__(self) self.name="installLinuxBuildTask" self.description="this task is used to install Linux build" self.stat = self.RUNNING self.info = "install Linux build task is running"
def __init__(self): Task.__init__(self) self.name="ClearSystemCacheTask" self.description="this task is used to clear system caches" self.stat = self.RUNNING self.info = "clear system cache task is running"
def __init__(self, channels = 8): Task.__init__(self) self.eventLoop = pyglet.app.EventLoop() self.channels = [Channel(i) for i in range(channels)]
def __init__(self, name, **kwds): """ Create AIPS task object Creates task object and calls server function to parse the task help and POPSDAT.HLP files to obtain task specific parametrs and documentation. Following is a list of class members: _default_dict = Dictionary with default values of parameters _input_list = List of input parameters in order _output_list = List of output parameters in order _min_dict = Parameter minimum values as a List _max_dict = Parameter maximum values as a List _hlp_dict = Parameter descriptions (list of strings) as a dictionary _strlen_dict = String parameter lengths as dictionary _help_string = Task Help documentation as list of strings _explain_string = Task Explain documentation as list of strings _short_help = One line description of task _message_list = list of execution messages Current parameter values are given as class members. """ if not self._task_type: self._task_type = 'AIPS' Task.__init__(self) self._name = name self._input_list = [] self._output_list = [] self._message_list = [] self._remainder = "" # Partial message buffer # Optional arguments. if 'version' in kwds: self.version = kwds['version'] else: if 'AIPS_VERSION' in os.environ: self.version = os.environ["AIPS_VERSION"] # Update default user number. if self.__class__.userno == 0: self.__class__.userno = AIPS.userno # See if there is a proxy that can hand us the details for # this task. params = None for proxy in AIPS.proxies: try: inst = getattr(proxy, self.__class__.__name__) params = inst.params(name, self.version) except Exception as exception: print(exception) if AIPS.debuglog: print(exception, file=AIPS.debuglog) continue break if not params: msg = "%s task '%s' is not available" % (self._package, name) raise RuntimeError(msg) # The XML-RPC proxy will return the details as a dictionary, # not a class. self._default_dict = params['default_dict'] self._input_list = params['input_list'] self._output_list = params['output_list'] self._min_dict = params['min_dict'] self._max_dict = params['max_dict'] self._hlp_dict = params['hlp_dict'] self._strlen_dict = params['strlen_dict'] self._help_string = params['help_string'] self._explain_string = params['explain_string'] self._short_help = params['short_help'] if self._task_type == 'OBIT': self._type_dict = params['type_dict'] self._dim_dict = params['dim_dict'] for adverb in self._default_dict: if type(self._default_dict[adverb]) == list: value = self._default_dict[adverb] self._default_dict[adverb] = List(self, adverb, value) # Initialize all adverbs to their default values. self.__dict__.update(self._default_dict) # The maximum value for disk numbers is bogus. for name in self._disk_adverbs: if name in self._max_dict: self._max_dict[name] = float(len(AIPS.disks) - 1) return # __init__
def __init__(self): self.logClassInits = Config.get("game", "log_class_inits") if self.logClassInits == 1: Log.debug("Input class init (Input.py)...") Task.__init__(self) self.mouse = pygame.mouse self.mouseListeners = [] self.keyListeners = [] self.systemListeners = [] self.priorityKeyListeners = [] self.controls = Player.Controls() self.activeGameControls = [] self.p2Nav = self.controls.p2Nav self.type1 = self.controls.type[0] self.keyCheckerMode = Config.get("game","key_checker_mode") self.disableKeyRepeat() self.gameGuitars = 0 self.gameDrums = 0 self.gameMics = 0 self.gameBots = 0 # Initialize joysticks pygame.joystick.init() self.joystickNames = {} self.joystickAxes = {} self.joystickHats = {} self.joyOff = False self.joysticks = [pygame.joystick.Joystick(id) for id in range(pygame.joystick.get_count())] for j in self.joysticks: j.init() self.joystickNames[j.get_id()] = j.get_name() self.joystickAxes[j.get_id()] = [0] * j.get_numaxes() self.joystickHats[j.get_id()] = [(0, 0)] * j.get_numhats() joyNum = len(self.joysticks) Log.debug("%d joysticks found." % (joyNum)) oldJoyNum = Config.get("game", "joysticks") if joyNum != oldJoyNum: self.joyOff = True Config.set("game", "joysticks", joyNum) # Enable music events Audio.Music.setEndEvent(MusicFinished) #Audio.Music.setEndEvent() #MFH - no event required? # Custom key names self.getSystemKeyName = pygame.key.name pygame.key.name = self.getKeyName if haveMidi: if ports: Log.debug("%d MIDI inputs found." % (len(ports))) try: for i in ports: midi[i].openPort(i, False) except Exception, e: Log.error("Error opening MIDI port %d: %s" % (i,str(e)) ) else: Log.warn("No MIDI input ports found.")
def __init__(self, engine, channel, fileName): Task.__init__(self) Sound.__init__(self, fileName) self.channel = channel
def __init__(self): self.logClassInits = Config.get("game", "log_class_inits") if self.logClassInits == 1: Log.debug("Input class init (Input.py)...") Task.__init__(self) self.mouse = pygame.mouse self.mouseListeners = [] self.keyListeners = [] self.systemListeners = [] self.priorityKeyListeners = [] self.controls = Controls() self.activeGameControls = [] self.p2Nav = self.controls.p2Nav self.type1 = self.controls.type[0] self.keyCheckerMode = Config.get("game","key_checker_mode") self.disableKeyRepeat() self.gameGuitars = 0 self.gameDrums = 0 self.gameMics = 0 self.gameBots = 0 # Initialize joysticks pygame.joystick.init() self.joystickNames = {} self.joystickAxes = {} self.joystickHats = {} self.joysticks = [pygame.joystick.Joystick(id) for id in range(pygame.joystick.get_count())] for j in self.joysticks: j.init() self.joystickNames[j.get_id()] = j.get_name() self.joystickAxes[j.get_id()] = [0] * j.get_numaxes() self.joystickHats[j.get_id()] = [(0, 0)] * j.get_numhats() Log.debug("%d joysticks found." % len(self.joysticks)) # Enable music events Audio.Music.setEndEvent(MusicFinished) #Audio.Music.setEndEvent() #MFH - no event required? # Custom key names self.getSystemKeyName = pygame.key.name pygame.key.name = self.getKeyName self.midi = [] if haveMidi: pygame.midi.init() for i in range(pygame.midi.get_count()): interface, name, is_input, is_output, is_opened = pygame.midi.get_device_info(i) Log.debug("Found MIDI device: %s on %s" % (name, interface)) if not is_input: Log.debug("MIDI device is not an input device.") continue try: self.midi.append(pygame.midi.Input(i)) Log.debug("Device opened as device number %d." % len(self.midi)) except pygame.midi.MidiException: Log.error("Error opening device for input.") if len(self.midi) == 0: Log.debug("No MIDI input ports found.") else: Log.notice("MIDI input support is not available; install at least pygame 1.9 to get it.")
def __init__(self): Task.__init__(self) self.name="StopClientTask" self.description="this task is used to stop client script" self.stat = self.RUNNING self.info = "stop client scripts is running"
def __init__(self): Task.__init__(self) self.name="ClearupTask" self.description="this task is used to clear an existing iserver build" self.stat = self.RUNNING self.info = "clearup task is running"
def __init__(self): Task.__init__(self) self.name="StopServerTask" self.description="this task is used to stop server" self.stat = self.RUNNING self.info = "stop Linux server task is running"