def __init__(self, product_id_bytes = None, *a, **k):
super(IdentifiableControlSurface, self).__init__(*a, **k)
raise product_id_bytes is not None or AssertionError
raise len(product_id_bytes) < 12 or AssertionError
self._product_id_bytes = product_id_bytes
self._request_task = self._tasks.add(Task.sequence(Task.wait(self.identity_request_delay), Task.run(self._send_identity_request)))
self._request_task.kill()
def add_mode(self, name, mode_or_component, toggle_value = False, groups = set(), behaviour = None):
"""
Adds a mode of the given name into the component. The mode
object should be a Mode or ControlSurfaceComponent instance.
The 'toggle_value' is the light value the toggle_botton will
be set to when the component is on this mode.
If 'group' is not None, the mode will be put in the group
identified by the passed object. When several modes are grouped:
* All the buttons in the group will light up when any of the
modes withing the group is selected.
* Any of the group buttons will cancel the current mode when
the current mode belongs to the group.
"""
if not name not in self._mode_map.keys():
raise AssertionError
if not isinstance(groups, set):
groups = set(groups)
mode = tomode(mode_or_component)
task = self._tasks.add(Task.sequence(Task.wait(Defaults.MOMENTARY_DELAY), Task.run(lambda : self._get_mode_behaviour(name).press_delayed(self, name))))
task.kill()
slot = self.register_slot(listener=partial(self._on_mode_button_value, name), event='value', extra_kws=dict(identify_sender=True))
self._mode_list.append(name)
self._mode_map[name] = _ModeEntry(mode=mode, toggle_value=toggle_value, behaviour=behaviour, subject_slot=slot, momentary_task=task, groups=groups)
button_setter = 'set_' + name + '_button'
hasattr(self, button_setter) or setattr(self, button_setter, partial(self.set_mode_button, name))
def declare_chain(name='',action='',ext_in='',ext_out='',reentrant=1,color='BLUE',install=0,before=[],after=[],decider=None):
if type(action)is types.StringType:
act=Task.simple_task_type(name,action,color=color)
else:
act=Task.task_type_from_func(name,action,color=color)
act.ext_in=tuple(Utils.to_list(ext_in))
act.ext_out=tuple(Utils.to_list(ext_out))
act.before=Utils.to_list(before)
act.after=Utils.to_list(after)
def x_file(self,node):
if decider:
ext=decider(self,node)
elif type(ext_out)is types.StringType:
ext=ext_out
if type(ext)is types.StringType:
out_source=node.change_ext(ext)
if reentrant:
self.allnodes.append(out_source)
elif type(ext)==types.ListType:
out_source=[node.change_ext(x)for x in ext]
if reentrant:
for i in xrange(reentrant):
self.allnodes.append(out_source[i])
else:
raise Utils.WafError("do not know how to process %s"%str(ext))
tsk=self.create_task(name)
tsk.set_inputs(node)
tsk.set_outputs(out_source)
if Options.is_install and install:
tsk.install=install
declare_extension(act.ext_in,x_file)
def DeleteButtonClicked(self):
#---- Delete Entries in file tasks ----
global taskList
currentTaskLine = str(self.ui.TaskListWidget.currentItem().text())
if not currentTaskLine == "":
self.ui.TaskListWidget.clear()
#self.count = 0
CTL = currentTaskLine.split(",")
f = open('tasks_test.txt')
output = []
for line in f:
line = line.rstrip("\n")
x = line.split(",")
if not CTL[1] == x[1]:
#print(line+","+str(predTaskId))
output.append(x[0]+","+x[1]+","+x[2]+"\n")
f.close()
f = open('tasks_test.txt', 'w')
f.writelines(output)
f.close()
for line in output:
line = line.rstrip("\n")
x = line.split(",")
self.ui.TaskListWidget.addItem(x[0]+","+x[1]+","+x[2])
#---- Create New task list ----
taskList = []
f = open('tasks_test.txt')
for line in f:
line = line.rstrip("\n")
x = line.split(",")
task = Task(int(x[0]),x[1])
task.duration = int(x[2])
preds = self.getPredecessorsFromFile(task.id)
task.predecessors = preds
taskList.append(task)
#self.ui.TaskListWidget.addItem(line)
f.close()
#---- Delete Entries in file dependencies---
self.ui.DependencyListWidget.clear()
#CTL
f = open('dependencies_test.txt')
output1 = []
for line in f:
line = line.rstrip("\n")
x = line.split(",")
if not int(CTL[0]) == int(x[0]):
#print(line+","+str(predTaskId)
str1 = ""
for i in range(0,len(x)):
if not int(x[i]) == int(CTL[0]):
str1=str1+str(x[i])+","
str1= str1.rstrip(",")
output1.append(str1+"\n")
f.close()
f = open('dependencies_test.txt', 'w')
f.writelines(output1)
f.close()
self.populateDependencyList()
def lerpLookAt(self, point, time = 1.0, blink = 0):
taskMgr.remove(self._ToonHead__stareAtName)
lodName = self.getLODNames()[0]
head = self.getPart('head', lodName)
startHpr = head.getHpr()
startLpupil = self._ToonHead__lpupil.getPos()
startRpupil = self._ToonHead__rpupil.getPos()
self._ToonHead__lookHeadAt(None, point, lod = lodName)
self._ToonHead__lookPupilsAt(None, point)
endHpr = head.getHpr()
endLpupil = self._ToonHead__lpupil.getPos() * 0.5
endRpupil = self._ToonHead__rpupil.getPos() * 0.5
head.setHpr(startHpr)
self._ToonHead__lpupil.setPos(startLpupil)
self._ToonHead__rpupil.setPos(startRpupil)
if startHpr.almostEqual(endHpr, 10):
return 0
if blink:
self.blinkEyes()
for lodName in self.getLODNames():
head = self.getPart('head', lodName)
head.lerpHpr(endHpr, time, blendType = 'easeInOut', task = self._ToonHead__stareAtName)
lookToTgt_TimeFraction = 0.20000000000000001
lookToTgtTime = time * lookToTgt_TimeFraction
returnToEyeCenterTime = time - lookToTgtTime - 0.5
origin = Point3(0, 0, 0)
blend_type = 'easeOut'
lPupilSeq = Task.sequence(self._ToonHead__lpupil.lerpPos(endLpupil, lookToTgtTime, blendType = blend_type), Task.pause(0.5), self._ToonHead__lpupil.lerpPos(origin, returnToEyeCenterTime, blendType = blend_type))
rPupilSeq = Task.sequence(self._ToonHead__rpupil.lerpPos(endRpupil, lookToTgtTime, blendType = blend_type), Task.pause(0.5), self._ToonHead__rpupil.lerpPos(origin, returnToEyeCenterTime, blendType = blend_type))
taskMgr.add(lPupilSeq, self._ToonHead__stareAtName)
taskMgr.add(rPupilSeq, self._ToonHead__stareAtName)
return 1
def setup(bld):
def run_unit_test(task):
""" Execute unit tests, creating a test.passed cache file. Based on
www.scons.org/wiki/UnitTest modified to run tests in the source dir """
import subprocess
import Options
test_exe = task.inputs[0]
app = test_exe.abspath(task.env)
blddir = os.path.dirname(app)
srcdir = os.path.dirname(test_exe.abspath())
cwd = None
if task.run_from_dir:
cwd = task.run_from_dir
target = os.path.join(blddir, task.outputs[0].name)
process_pipe = subprocess.Popen(app, stdout=subprocess.PIPE, cwd=cwd)
process_pipe.wait()
returncode = process_pipe.returncode
stdout = process_pipe.stdout.read()
if Options.options.verbose or returncode:
if task.run_from_dir:
# this sorts out jump-to-errors in e.g. vim
print "waf: Entering directory `%s'" % (bld.bdir)
print stdout
out = "FAILED"
if returncode == 0:
out = stdout
open(str(target), "w").write(out + "\n")
return returncode
Task.task_type_from_func("unit_test", vars=[], func=run_unit_test, color="RED", after="cxx_link")
def declare_chain(name='',action='',ext_in='',ext_out='',reentrant=True,color='BLUE',install=0,before=[],after=[],decider=None,rule=None,scan=None):
action=action or rule
if isinstance(action,str):
act=Task.simple_task_type(name,action,color=color)
else:
act=Task.task_type_from_func(name,action,color=color)
act.ext_in=tuple(Utils.to_list(ext_in))
act.ext_out=tuple(Utils.to_list(ext_out))
act.before=Utils.to_list(before)
act.after=Utils.to_list(after)
act.scan=scan
def x_file(self,node):
if decider:
ext=decider(self,node)
else:
ext=ext_out
if isinstance(ext,str):
out_source=node.change_ext(ext)
if reentrant:
self.allnodes.append(out_source)
elif isinstance(ext,list):
out_source=[node.change_ext(x)for x in ext]
if reentrant:
for i in xrange((reentrant is True)and len(out_source)or reentrant):
self.allnodes.append(out_source[i])
else:
raise Utils.WafError("do not know how to process %s"%str(ext))
tsk=self.create_task(name,node,out_source)
if node.__class__.bld.is_install:
tsk.install=install
declare_extension(act.ext_in,x_file)
def __init__(self, name, system_id, client_id, **kwargs):
Task.__init__(self, name, system_id, client_id)
#print("Created task: %s" % str(self.task_id))
self.target_hash = kwargs['target_hash']
self.start = kwargs['start']
self.end = kwargs['end']
def showChanceRewards(self):
tasks = []
index = 0
for reward in self.rewardList:
if reward != -1:
hcc = Task.Task(self.hideChanceMarker)
hcc.chanceMarkers = self.chanceMarkers
hcc.index = index
sct = Task.Task(self.showChanceCard)
sct.chanceCard = self.chanceCard
sct.cardSound = self.cardSound
stt = Task.Task(self.showChanceCardText)
rewardEntry = RaceGameGlobals.ChanceRewards[reward]
stt.rewardIdx = reward
if rewardEntry[0][0] < 0 or rewardEntry[0][1] > 0:
stt.sound = self.negBuzzer
else:
stt.sound = self.posBuzzer
stt.picker = self.avIdList[index]
stt.chanceCard = self.chanceCard
rct = Task.Task(self.resetChanceCard)
rct.chanceCard = self.chanceCard
task = Task.sequence(hcc, sct, Task.pause(1.0), stt, Task.pause(3.0), rct, Task.pause(1.0))
tasks.append(task)
index += 1
return tasks
def __init__(self, mode = None, delay = None, parent_task_group = None, *a, **k):
super(DelayMode, self).__init__(*a, **k)
raise mode is not None or AssertionError
raise parent_task_group is not None or AssertionError
delay = delay or Defaults.MOMENTARY_DELAY
self._mode = tomode(mode)
self._mode_entered = False
self._delay_task = parent_task_group.add(Task.sequence(Task.wait(delay), Task.run(self._enter_mode_delayed)))
self._delay_task.kill()
def declare_chain(
name="",
action="",
ext_in="",
ext_out="",
reentrant=True,
color="BLUE",
install=0,
before=[],
after=[],
decider=None,
rule=None,
scan=None,
):
"""
see Tools/flex.py for an example
while i do not like such wrappers, some people really do
"""
action = action or rule
if isinstance(action, str):
act = Task.simple_task_type(name, action, color=color)
else:
act = Task.task_type_from_func(name, action, color=color)
act.ext_in = tuple(Utils.to_list(ext_in))
act.ext_out = tuple(Utils.to_list(ext_out))
act.before = Utils.to_list(before)
act.after = Utils.to_list(after)
act.scan = scan
def x_file(self, node):
if decider:
ext = decider(self, node)
else:
ext = ext_out
if isinstance(ext, str):
out_source = node.change_ext(ext)
if reentrant:
self.allnodes.append(out_source)
elif isinstance(ext, list):
out_source = [node.change_ext(x) for x in ext]
if reentrant:
for i in xrange((reentrant is True) and len(out_source) or reentrant):
self.allnodes.append(out_source[i])
else:
# XXX: useless: it will fail on Utils.to_list above...
raise Utils.WafError("do not know how to process %s" % str(ext))
tsk = self.create_task(name, node, out_source)
if node.__class__.bld.is_install:
tsk.install = install
declare_extension(act.ext_in, x_file)
return x_file
def _DistributedCannonGame__fireCannonTask(self, task):
launchTime = task.fireTime
avId = task.avId
self.notify.debug('FIRING CANNON FOR AVATAR ' + str(avId))
flightResults = self._DistributedCannonGame__calcFlightResults(avId, launchTime)
for key in flightResults:
exec "%s = flightResults['%s']" % (key, key)
self.notify.debug('start position: ' + str(startPos))
self.notify.debug('start velocity: ' + str(startVel))
self.notify.debug('time of launch: ' + str(launchTime))
self.notify.debug('time of impact: ' + str(timeOfImpact))
self.notify.debug('location of impact: ' + str(trajectory.getPos(timeOfImpact)))
if hitWhat == self.HIT_WATER:
self.notify.debug('toon will land in the water')
elif hitWhat == self.HIT_TOWER:
self.notify.debug('toon will hit the tower')
else:
self.notify.debug('toon will hit the ground')
head = self.toonHeadDict[avId]
head.stopBlink()
head.stopLookAroundNow()
head.reparentTo(hidden)
av = self.toonModelDict[avId]
av.reparentTo(render)
av.setPos(startPos)
av.setHpr(startHpr)
avatar = self.getAvatar(avId)
avatar.loop('swim')
avatar.setPosHpr(0, 0, -(avatar.getHeight() / 2.0), 0, 0, 0)
shootTask = Task.Task(self._DistributedCannonGame__shootTask)
flyTask = Task.Task(self._DistributedCannonGame__flyTask)
seqDoneTask = Task.Task(self._DistributedCannonGame__flySequenceDoneTask)
info = { }
info['avId'] = avId
info['trajectory'] = trajectory
info['launchTime'] = launchTime
info['timeOfImpact'] = timeOfImpact
info['hitWhat'] = hitWhat
info['toon'] = self.toonModelDict[avId]
info['hRot'] = self.cannonPositionDict[avId][0]
info['haveWhistled'] = 0
info['maxCamPullback'] = CAMERA_PULLBACK_MIN
(info['timeEnterTowerXY'], info['timeExitTowerXY']) = trajectory.calcEnterAndLeaveCylinderXY(self.tower.getPos(render), TOWER_RADIUS)
shootTask.info = info
flyTask.info = info
seqDoneTask.info = info
seqTask = Task.sequence(shootTask, flyTask, Task.pause(LAND_TIME), seqDoneTask)
taskMgr.add(seqTask, 'flyingToon' + str(avId))
if avId == self.localAvId:
if info['hitWhat'] == self.HIT_WATER:
self.sendUpdate('setToonWillLandInWater', [
info['timeOfImpact']])
return Task.done
def __init__(self, name, system_id, client_id, **kwargs):
Task.__init__(self, name, system_id, client_id)
self.start_x = kwargs['start_x']
self.rows = kwargs['rows']
self.cols = kwargs['cols']
self.min_y = kwargs['min_y']
self.min_x = kwargs['min_x']
self.pixel_size_y = kwargs['pixel_size_y']
self.pixel_size_x = kwargs['pixel_size_x']
self.iters = kwargs['iters']
def Remove(addr):
try:
for c in clients:
if c['address'] == addr:
if c['type'] == CLIENT_ADMIN:
print("\033[1;33madmin removed [%s from %s]\033[0m" % (c['username'], c['address']))
elif c['type'] == CLIENT_SLAVE:
print("\033[1;32madmin removed [%s from %s]\033[0m" % (c['hostname'], c['address']))
Task.setTask(Task.getTaskBySlaveAddr(addr), Task.STATE_BROKEN)
clients.remove(c)
except ValueError:
pass
def irisOutTask(self, task, time = 0.5, noIris = 1):
if noIris:
def noIrisTask(task):
task.noIris()
return Task.done
nit = Task.Task(noIrisTask)
nit.noIris = self.noIris
seq = Task.sequence(self.irisOut(time, block = 1), task, nit)
else:
seq = Task.sequence(self.irisOut(time, block = 1), task)
taskMgr.add(seq, 'irisOutTaskSeq')
def fadeOutTask(self, task, time = 0.29999999999999999, noFade = 1):
if noFade:
def noFadeTask(task):
task.noFade()
return Task.done
nft = Task.Task(noFadeTask)
nft.noFade = self.noFade
seq = Task.sequence(self.fadeOut(time, block = 1), task, nft)
else:
seq = Task.sequence(self.fadeOut(time, block = 1), task)
taskMgr.add(seq, 'fadeOutTaskSeq')
def __init__(self, msg_type = None, channel = None, identifier = None, sysex_identifier = None, request_rebuild_midi_map = None, *a, **k):
raise msg_type in MIDI_MSG_TYPES or AssertionError
raise in_range(channel, 0, 16) or channel is None or AssertionError
raise in_range(identifier, 0, 128) or identifier is None or AssertionError
raise msg_type != MIDI_SYSEX_TYPE or channel == None or AssertionError
raise msg_type != MIDI_SYSEX_TYPE or identifier == None or AssertionError
raise msg_type == MIDI_SYSEX_TYPE or sysex_identifier == None or AssertionError
super(InputControlElement, self).__init__(*a, **k)
self._request_rebuild = request_rebuild_midi_map
self._msg_type = msg_type
self._msg_channel = channel
self._msg_identifier = identifier
self._msg_sysex_identifier = sysex_identifier
self._original_channel = channel
self._original_identifier = identifier
self._needs_takeover = True
self._is_mapped = True
self._is_being_forwarded = True
self._delayed_messages = []
self._force_next_send = False
self._mapping_feedback_delay = 0
self._mapping_sensitivity = 1.0
self._send_delayed_messages_task = self._tasks.add(Task.run(self._send_delayed_messages))
self._send_delayed_messages_task.kill()
self._parameter_to_map_to = None
self._in_parameter_gesture = False
self._last_sent_message = None
self._report_input = False
self._report_output = False
def __init__(self, *a, **k):
super(TransportComponent, self).__init__(*a, **k)
self._ffwd_button = None
self._rwd_button = None
self._tap_tempo_button = None
self._tempo_control = None
self._tempo_fine_control = None
self._song_position_control = None
self._rwd_task = Task.Task()
self._ffwd_task = Task.Task()
self._fine_tempo_needs_pickup = True
self._prior_fine_tempo_value = -1
self._end_undo_step_task = self._tasks.add(Task.sequence(Task.wait(1.5), Task.run(self.song().end_undo_step)))
self._end_undo_step_task.kill()
song = self.song()
self._loop_toggle, self._punch_in_toggle, self._punch_out_toggle, self._record_toggle, self._play_toggle, self._stop_toggle, self._nudge_down_toggle, self._nudge_up_toggle, self._metronome_toggle, self._session_record_toggle, self.arrangement_overdub_toggle, self._overdub_toggle = self.register_components(ToggleComponent('loop', song), ToggleComponent('punch_in', song, is_momentary=True), ToggleComponent('punch_out', song, is_momentary=True), ToggleComponent('record_mode', song), ToggleComponent('is_playing', song, model_transform=const(True)), ToggleComponent('is_playing', song, model_transform=const(False), view_transform=const(False)), ToggleComponent('nudge_down', song, is_momentary=True), ToggleComponent('nudge_up', song, is_momentary=True), ToggleComponent('metronome', song), ToggleComponent('session_record', song), ToggleComponent('arrangement_overdub', song), ToggleComponent('overdub', song))
def get_task(): """ :rtype : object """ obj_str = r.blpop(settings.WORKER_NAME) return Task.deserialize(obj_str)
def showLaffString(self, text, duration = 0.84999999999999998, scale = 0.69999999999999996):
if self.LaffNumbersEnabled:
if text != '':
if self.laffNumber:
self.hideLaffNumber()
self.LaffNumberGenerator.setFont(ToontownGlobals.getSignFont())
self.LaffNumberGenerator.setText(text)
self.LaffNumberGenerator.clearShadow()
self.LaffNumberGenerator.setAlign(TextNode.ACenter)
r = 1.0
a = 1.0
g = 0.0
b = 0.0
self.LaffNumberGenerator.setTextColor(r, g, b, a)
self.laffNumberNode = self.LaffNumberGenerator.generate()
self.laffNumber = self.attachNewNode(self.laffNumberNode)
self.laffNumber.setScale(scale)
self.laffNumber.setBillboardAxis()
self.laffNumber.setPos(0, 0, self.height / 2)
seq = Task.sequence(self.laffNumber.lerpPos(Point3(0, 0, self.height + 1.5), 1.0, blendType = 'easeOut'), Task.pause(duration), self.laffNumber.lerpColor(Vec4(r, g, b, a), Vec4(r, g, b, 0), 0.10000000000000001), Task.Task(self.hideLaffNumberTask))
taskMgr.add(seq, self.uniqueName('laffNumber'))
return None
def runInPlace(self, avatar, lane, currentPlace, newPlace, time):
place = min(newPlace, len(self.posHprArray[lane]) - 1)
step = (place - currentPlace) / 3
pos1 = self.posHprArray[lane][currentPlace + step]
pos2 = self.posHprArray[lane][currentPlace + 2 * step]
pos3 = self.posHprArray[lane][place]
def startRun(task):
task.avatar.setAnimState('run', 1)
return Task.done
startRunTask = Task.Task(startRun, 'startRun-' + str(lane))
startRunTask.avatar = avatar
def stopRun(task, raceBoard = self.raceBoard, pos3 = pos3):
task.avatar.setAnimState('neutral', 1)
task.avatar.setPosHpr(raceBoard, pos3[0], pos3[1], pos3[2], pos3[3], 0, 0)
return Task.done
stopRunTask = Task.Task(startRun, 'stopRun-' + str(lane))
stopRunTask.avatar = avatar
runTask = Task.sequence(startRunTask, avatar.lerpPosHpr(pos1[0], pos1[1], pos1[2], pos1[3], 0, 0, time / 3.0, other = self.raceBoard), avatar.lerpPosHpr(pos2[0], pos2[1], pos2[2], pos2[3], 0, 0, time / 3.0, other = self.raceBoard), avatar.lerpPosHpr(pos3[0], pos3[1], pos3[2], pos3[3], 0, 0, time / 3.0, other = self.raceBoard), stopRunTask)
runTask.avatar = avatar
runTask.pos3 = pos3
runTask.raceBoard = self.raceBoard
taskMgr.add(runTask, 'runAvatar-' + str(lane))
def walkInPlace(self, avatar, lane, place, time):
place = min(place, len(self.posHprArray[lane]) - 1)
posH = self.posHprArray[lane][place]
def startWalk(task):
task.avatar.setAnimState('walk', 1)
return Task.done
startWalkTask = Task.Task(startWalk, 'startWalk-' + str(lane))
startWalkTask.avatar = avatar
def stopWalk(task, raceBoard = self.raceBoard, posH = posH):
task.avatar.setAnimState('neutral', 1)
if raceBoard.isEmpty():
task.avatar.setPosHpr(0, 0, 0, 0, 0, 0)
else:
task.avatar.setPosHpr(raceBoard, posH[0], posH[1], posH[2], posH[3], 0, 0)
return Task.done
stopWalkTask = Task.Task(stopWalk, 'stopWalk-' + str(lane))
stopWalkTask.avatar = avatar
walkTask = Task.sequence(startWalkTask, avatar.lerpPosHpr(posH[0], posH[1], posH[2], posH[3], 0, 0, time, other = self.raceBoard), stopWalkTask)
walkTask.avatar = avatar
walkTask.posH = posH
walkTask.raceBoard = self.raceBoard
taskMgr.add(walkTask, 'walkAvatar-' + str(lane))
def setup(bld):
for name in('cc','cxx'):
if name not in Task.TaskBase.classes:
continue
task=Task.TaskBase.classes[name]
line=task.run.code.replace('SRC','SRC[0].abspath(env)')
(fun,v)=Task.compile_fun(name,line,False)
fun.code=line
task.run=fun
def declare_chain(name='', action='', ext_in='', ext_out='', reentrant=1, color='BLUE', install=0, before=[], after=[], decider=None, rule=None):
"""
see Tools/flex.py for an example
while i do not like such wrappers, some people really do
"""
action = action or rule
if type(action) is types.StringType:
act = Task.simple_task_type(name, action, color=color)
else:
act = Task.task_type_from_func(name, action, color=color)
act.ext_in = tuple(Utils.to_list(ext_in))
act.ext_out = tuple(Utils.to_list(ext_out))
act.before = Utils.to_list(before)
act.after = Utils.to_list(after)
def x_file(self, node):
if decider:
ext = decider(self, node)
elif type(ext_out) is types.StringType:
ext = ext_out
if type(ext) is types.StringType:
out_source = node.change_ext(ext)
if reentrant:
self.allnodes.append(out_source)
elif type(ext) == types.ListType:
out_source = [node.change_ext(x) for x in ext]
if reentrant:
for i in xrange(reentrant):
self.allnodes.append(out_source[i])
else:
# XXX: useless: it will fail on Utils.to_list above...
raise Utils.WafError("do not know how to process %s" % str(ext))
tsk = self.create_task(name)
tsk.set_inputs(node)
tsk.set_outputs(out_source)
if Options.is_install and install:
tsk.install = install
declare_extension(act.ext_in, x_file)
def setCannonWillFire(self, avId, fireTime, zRot, angle):
if not self._DistributedCannonGame__playing():
return None
self.notify.debug('setCannonWillFire: ' + str(avId) + ': zRot=' + str(zRot) + ', angle=' + str(angle) + ', time=' + str(fireTime))
self.cannonPositionDict[avId][0] = zRot
self.cannonPositionDict[avId][1] = angle
self._DistributedCannonGame__updateCannonPosition(avId)
task = Task.Task(self._DistributedCannonGame__fireCannonTask)
task.avId = avId
task.fireTime = fireTime
timeToWait = task.fireTime - self.getCurrentGameTime()
if timeToWait > 0.0:
fireTask = Task.sequence(Task.pause(timeToWait), task)
else:
fireTask = task
fireTask = task
taskMgr.add(fireTask, 'fireCannon' + str(avId))
self.airborneToons += 1
def NewTaskButtonClicked(self):
Dialog = frmDialog(self)
Dialog.show()
ret = Dialog.exec_()
global taskName,taskDuration,isAdded,taskList
if(isAdded):
self.count+=1
self.ui.TaskListWidget.addItem(str(self.count)+","+taskName+","+taskDuration)
self.populateDependencyList()
task = Task(self.count,taskName)
task.duration = int(taskDuration)
taskList.append(task)
f = open('tasks_test.txt','a')
f.write(str(self.count)+","+taskName+","+taskDuration+"\n")
f.close()
f1 = open('dependencies_test.txt','a')
f1.write(str(self.count)+"\n")
f1.close()
def __init__(self, *a, **k):
super(ModesComponent, self).__init__(*a, **k)
self._last_toggle_value = 0
self._mode_toggle = None
self._mode_toggle_task = self._tasks.add(Task.wait(Defaults.MOMENTARY_DELAY))
self._mode_toggle_task.kill()
self._mode_list = []
self._mode_map = {}
self._last_selected_mode = None
self._mode_stack = StackingResource(self._do_enter_mode, self._do_leave_mode)
self._shift_button = None
def create_xml2po_task(lang):
node = self.path.find_resource(lang + os.sep + lang+'.po')
src = self.path.find_resource('C' + os.sep + self.doc_module+'.xml')
out = self.path.find_or_declare(lang + os.sep + self.doc_module+'.xml')
if self.env['IS_WIN32']:
# FIXME - xml2po on win32 fails with flags containing backslashes '\'
# failing example: python xml2po -e -p fr\fr.po C\xiphos.xml
node_str = replace_backslash(node)
src_str = replace_backslash(src)
# it is necessary pas to xml2po only paths with '/'
Task.simple_task_type('xml2po',
'${XML2PO} -e -p %s %s > ${TGT}' % (node_str, src_str),
color='BLUE')
tsk = self.create_task('xml2po')
tsk.set_inputs([node, src])
# waf will control output file if it exists, when task is done
tsk.set_outputs(out)
return tsk, out
def schedule_message(self, delay_in_ticks, callback, parameter = None):
""" Schedule a callback to be called after a specified time """
if not delay_in_ticks > 0:
raise AssertionError
if not callable(callback):
raise AssertionError
self._is_sending_scheduled_messages or delay_in_ticks -= 1
message_reference = [None]
def message(delta):
if parameter:
callback(parameter)
else:
callback()
self._remaining_scheduled_messages.remove(message_reference)
message_reference[0] = message
self._remaining_scheduled_messages.append(message_reference)
delay_in_ticks and self._task_group.add(Task.sequence(Task.delay(delay_in_ticks), message))
else:
self._task_group.add(message)
def judge_json(self, json_data, con_sock):
"""
get the json data like:
{"NODES":env}
{"TASKS":task}
{"OUPUT":msg}
"""
print '[NOTICE]:get data is', json_data
tuple_addr = con_sock.getsockname()
if json_data.has_key("NODES"):
node = Server.Node(tuple_addr[0], tuple_addr[1], json_data["NODES"], con_sock)
self._nodes.append(node)
elif json_data.has_key("TASKS"):
task = Task.Task(tuple_addr[0], tuple_addr[1], con_sock, json_data["TASKS"])
if task.get_task_msg() != dict():
self._tasks.append(task)
else:
task.get_sock().close()
elif json_data.has_key("OUTPUT"):
self.exchange_msg(json_data["OUTPUT"], con_sock)
else:
print "[Error]:the msg is not a node or task"
class UnmountTask(Task.LoggingTask):
def __init__(self, job, hdd):
Task.LoggingTask.__init__(self, job, _("Unmount"))
self.hdd = hdd
self.mountpoints = []
def prepare(self):
try:
dev = self.hdd.disk_path.split('/')[-1]
open('/dev/nomount.%s' % dev, "wb").close()
except Exception, e:
print "ERROR: Failed to create /dev/nomount file:", e
self.setTool('umount')
self.args.append('-f')
for dev in self.hdd.enumMountDevices():
self.args.append(dev)
self.postconditions.append(Task.ReturncodePostcondition())
self.mountpoints.append(dev)
if not self.mountpoints:
print "UnmountTask: No mountpoints found?"
self.cmd = 'true'
self.args = [self.cmd]
def __start_task(self, ra, dec, fov, lowermag, uppermag, star_catalog):
cat_obj = {'usnob': self.usnob, 'gsc': self.gsc, 'sao': self.sao}
method = 'search'
task_list = []
for catalog in star_catalog.split(','):
catalog = catalog.strip()
self.logger.debug("%s thread starting..." % catalog)
cat = cat_obj[catalog]
#search = ("self.%s.search" %catalog)
try:
search = getattr(cat, method)
#t = Task.FuncTask(eval(search), [ra, dec, fov, lowermag, uppermag], {}, logger=self.logger)
t = Task.FuncTask(search, [ra, dec, fov, lowermag, uppermag],
{},
logger=self.logger)
task_list.append(t)
except Exception as e:
self.logger.error('error: starting task. %s' % str(e))
continue
return task_list
def apply_qt4(self):
if getattr(self, 'lang', None):
update = getattr(self, 'update', None)
lst = []
trans = []
for l in self.to_list(self.lang):
if not isinstance(l, Node.Node):
l = self.path.find_resource(l + '.ts')
t = self.create_task('ts2qm')
t.set_inputs(l)
t.set_outputs(l.change_ext('.qm'))
lst.append(t.outputs[0])
if update:
trans.append(t.inputs[0])
if update and Options.options.trans_qt4:
# we need the cpp files given, except the rcc task we create after
# FIXME may be broken
u = Task.TaskCmd(translation_update, self.env, 2)
u.inputs = [a.inputs[0] for a in self.compiled_tasks]
u.outputs = trans
if getattr(self, 'langname', None):
t = Task.TaskBase.classes['qm2rcc'](self.env)
t.set_inputs(lst)
t.set_outputs(self.path.find_or_declare(self.langname + '.qrc'))
t.path = self.path
k = create_rcc_task(self, t.outputs[0])
self.link_task.inputs.append(k.outputs[0])
lst = []
for flag in self.to_list(self.env['CXXFLAGS']):
if len(flag) < 2: continue
if flag[0:2] == '-D' or flag[0:2] == '-I':
lst.append(flag)
self.env['MOC_FLAGS'] = lst
def createExt4ConversionJob(self):
if not isFileSystemSupported('ext4'):
raise Exception, _("You system does not support ext4")
job = Task.Job(_("Convert ext3 to ext4..."))
if not path.exists('/sbin/tune2fs'):
task = Task.LoggingTask(job, "update packages")
task.setTool('opkg')
task.args.append('update')
task = Task.LoggingTask(job, "Install e2fsprogs-tune2fs")
task.setTool('opkg')
task.args.append('install')
task.args.append('e2fsprogs-tune2fs')
if self.findMount():
# Create unmount task if it was not mounted
UnmountTask(job, self)
dev = self.mount_device
else:
# otherwise, assume there is one partition
dev = self.partitionPath("1")
task = Task.LoggingTask(job, "fsck")
task.setTool('fsck.ext3')
task.args.append('-p')
task.args.append(dev)
task = Task.LoggingTask(job, "tune2fs")
task.setTool('tune2fs')
task.args.append('-O')
task.args.append('extents,uninit_bg,dir_index')
task.args.append('-o')
task.args.append('journal_data_writeback')
task.args.append(dev)
task = Task.LoggingTask(job, "fsck")
task.setTool('fsck.ext4')
task.postconditions = [] # ignore result, it will always "fail"
task.args.append('-f')
task.args.append('-p')
task.args.append('-D')
task.args.append(dev)
MountTask(job, self)
task = Task.ConditionTask(job, _("Wait for mount"))
task.check = self.mountDevice
return job
def setup(bld):
outfile = ''
if sys.platform.startswith('linux'):
outfile = ' > /dev/null'
ndstool_str = '${NDSTOOL} -c ${TGT} -9 ${SRC[0].bldpath(env)} %s ' + outfile
Task.simple_task_type('ndstool',
ndstool_str % '',
before='unit_test',
after='elf2bin')
Task.simple_task_type('ndstool_banner',
ndstool_str %
" -b ${SRC[1].srcpath(env)} '${NDSTOOL_BANNER}'",
before='unit_test',
after='elf2bin')
Task.simple_task_type('elf2bin',
'${OBJCOPY} -O binary ${SRC} ${TGT}',
after='cc_link cxx_link')
def __init__(self, c_instance = None, publish_self = True, *a, **k):
""" Define and Initialize standard behavior """
super(ControlSurface, self).__init__(*a, **k)
if not c_instance:
raise AssertionError
self.canonical_parent = None
publish_self and publish_control_surface(self)
self._c_instance = c_instance
self.log_message('Initialising...')
self._pad_translations = None
self._suggested_input_port = str('')
self._suggested_output_port = str('')
self._components = []
self._displays = []
self.controls = []
self._highlighting_session_component = None
self._device_component = None
self._device_selection_follows_track_selection = False
self._forwarding_long_identifier_registry = {}
self._forwarding_registry = {}
self._is_sending_scheduled_messages = BooleanContext()
self._remaining_scheduled_messages = []
self._task_group = Task.TaskGroup(auto_kill=False)
self._in_build_midi_map = BooleanContext()
self._suppress_requests_counter = 0
self._rebuild_requests_during_suppression = 0
self._enabled = True
self._in_component_guard = BooleanContext()
self._accumulate_midi_messages = BooleanContext()
self._midi_message_dict = {}
self._midi_message_list = []
self._midi_message_count = 0
self._control_surface_injector = inject(parent_task_group=const(self._task_group), show_message=const(self.show_message), log_message=const(self.log_message), register_component=const(self._register_component), register_control=const(self._register_control), request_rebuild_midi_map=const(self.request_rebuild_midi_map), set_pad_translations=const(self.set_pad_translations), send_midi=const(self._send_midi), song=self.song).everywhere()
with self.setting_listener_caller():
self.register_slot(self.song(), self._on_track_list_changed, 'visible_tracks')
self.register_slot(self.song(), self._on_scene_list_changed, 'scenes')
self.register_slot(self.song().view, self._on_selected_track_changed, 'selected_track')
self.register_slot(self.song().view, self._on_selected_scene_changed, 'selected_scene')
def __init__(self,
msg_type=None,
channel=None,
identifier=None,
sysex_identifier=None,
request_rebuild_midi_map=None,
*a,
**k):
raise msg_type in MIDI_MSG_TYPES or AssertionError
raise in_range(channel, 0, 16) or channel is None or AssertionError
raise in_range(identifier, 0,
128) or identifier is None or AssertionError
raise msg_type != MIDI_SYSEX_TYPE or channel == None or AssertionError
raise msg_type != MIDI_SYSEX_TYPE or identifier == None or AssertionError
raise msg_type == MIDI_SYSEX_TYPE or sysex_identifier == None or AssertionError
super(InputControlElement, self).__init__(*a, **k)
self._request_rebuild = request_rebuild_midi_map
self._msg_type = msg_type
self._msg_channel = channel
self._msg_identifier = identifier
self._msg_sysex_identifier = sysex_identifier
self._original_channel = channel
self._original_identifier = identifier
self._needs_takeover = True
self._is_mapped = True
self._is_being_forwarded = True
self._delayed_messages = []
self._force_next_send = False
self._mapping_feedback_delay = 0
self._mapping_sensitivity = 1.0
self._send_delayed_messages_task = self._tasks.add(
Task.run(self._send_delayed_messages))
self._send_delayed_messages_task.kill()
self._parameter_to_map_to = None
self._in_parameter_gesture = False
self._last_sent_message = None
self._report_input = False
self._report_output = False
def updateTask(self, tasktaskNameVar, descriptionVar, dateVar, priorityVar, whichSelected):
try:
self.todoitem = Task(tasktaskNameVar, descriptionVar, priorityVar, dateVar, self.today)
conn = pymysql.connect(host='127.0.0.1', user='******', passwd=None, db='todolist')
cur = conn.cursor()
update_task = "UPDATE task SET TaskTitle=%s, TaskDescription=%s, TaskPriority=%s, TaskDueDate=%s, CreationDate=%s WHERE TaskTitle=%s AND TaskDescription=%s AND TaskPriority=%s AND TaskDueDate=%s AND CreationDate=%s"
task_data = (self.todoitem.TaskTitle, self.todoitem.TaskDescription, self.todoitem.TaskPriority, self.todoitem.TaskDueDate, self.todoitem.CreationDate,
self.taskList[whichSelected].TaskTitle, self.taskList[whichSelected].TaskDescription,
self.taskList[whichSelected].TaskPriority, self.taskList[whichSelected].TaskDueDate, self.taskList[whichSelected].CreationDate)
cur.execute(update_task, task_data)
conn.commit()
cur.close()
conn.close()
self.taskList[whichSelected] = self.todoitem
except ValueError:
print("Please select an task to update")
except TypeError:
print("Type Error")
def setUp(self):
"""
- Initialize logger
- Create 20-thread thread pool
- Make a fake parentTask using the thread pool
"""
if LOGDEBUG:
print "\n*** TestTask01: setting up thread pool"
self.logger = logging.getLogger( 'TestTask01Logger' )
self.logger.setLevel(logging.WARN)
self.tpool = Task.ThreadPool(numthreads=20, logger=self.logger)
self.tpool.startall(wait=True)
# Make a fake 'parent' task
self.parentTask = make_SimpleTask('t1')
self.parentTask.tag = 'tasks'
sl = logging.getLogger( 'TestTask01ParentLogger' )
sl.setLevel(logging.WARN)
self.parentTask.logger = sl
self.parentTask.threadPool = self.tpool
def __init__(self):
self.sepwin = []
super().__init__()
self.setupUi(self)
self.setWindowIcon(
QIcon('.computerhousekeeper\\img\\ComputerHousekeeper.jpg'))
self.task = Task()
self.tool = Tool()
self.more = More()
self.qsl = QStackedLayout(self.frame_ui)
self.qsl.addWidget(self.task)
self.qsl.addWidget(self.tool)
self.qsl.addWidget(self.more)
self.pushButton_task.clicked.connect(self.show_panel)
self.pushButton_task.customContextMenuRequested.connect(
self.pushButton_task_showrightmenu)
self.pushButton_tool.clicked.connect(self.show_panel)
self.pushButton_tool.customContextMenuRequested.connect(
self.pushButton_tool_showrightmenu)
self.pushButton_more.clicked.connect(self.show_panel)
self.pushButton_more.customContextMenuRequested.connect(
self.pushButton_more_showrightmenu)
self.tool.listWidget_tool.doubleClicked.connect(self.start_tool)
self.tool.listWidget_tool.doubleClicked.disconnect(
self.tool.start_tool)
self.pushButton_task.setIcon(
QIcon('.computerhousekeeper\\img\\task.jpg'))
self.pushButton_tool.setIcon(
QIcon('.computerhousekeeper\\img\\tool.jpg'))
self.pushButton_more.setIcon(
QIcon('.computerhousekeeper\\img\\more.jpg'))
logging.info(f'初始化{type(self).__name__}窗口')
def _DistributedCannonGame__startIntro(self):
self.T_WATER = 1
self.T_WATER2LONGVIEW = 1
self.T_LONGVIEW = 1
self.T_LONGVIEW2TOONHEAD = 2
self.T_TOONHEAD = 2
self.T_TOONHEAD2CANNONBACK = 2
taskLookInWater = Task.Task(self._DistributedCannonGame__taskLookInWater)
taskPullBackFromWater = Task.Task(self._DistributedCannonGame__taskPullBackFromWater)
taskFlyUpToToon = Task.Task(self._DistributedCannonGame__flyUpToToon)
taskFlyToBackOfCannon = Task.Task(self._DistributedCannonGame__flyToBackOfCannon)
commonData = { }
taskLookInWater.data = commonData
taskPullBackFromWater.data = commonData
taskFlyUpToToon.data = commonData
taskFlyToBackOfCannon.data = commonData
introTask = Task.sequence(taskLookInWater, Task.pause(self.T_WATER), taskPullBackFromWater, Task.pause(self.T_WATER2LONGVIEW + self.T_LONGVIEW), taskFlyUpToToon, Task.pause(self.T_LONGVIEW2TOONHEAD + self.T_TOONHEAD), taskFlyToBackOfCannon)
taskMgr.add(introTask, self.INTRO_TASK_NAME)
def post(self):
# get data ,return error page if it's empty
try:
fileinfo = self.request.files["rbf_gamma_data"][0]
rbf_gamma_data = fileinfo["body"]
except KeyError:
self.render("error.html", error_info="Please Upload Your Data.")
return
try:
# save data for calculate
filename = upload_dir + fileinfo["filename"]
while os.path.exists(filename):
filename = filename + str(random.randint(1, 9))
f = open(filename, "w")
f.write(rbf_gamma_data)
f.close()
min_g = float(self.get_argument("gamma_min", "1"))
max_g = float(self.get_argument("gamma_max", "10"))
step = float(self.get_argument("gamma_step", "1"))
C = float(self.get_argument("C", "1"))
# min_g = 1.0e-8
# max_g = 2.0e-8
# step = 1e-9
# task of calculate with different gamma of RBF
rgTask = Task.RBFGammaTask(filename, min_g, max_g, step, C)
# remove data after calculating
except Exception, e:
os.remove(filename)
self.render(
"error.html", error_info="Please Check Your Data Format or Selected Gammas")
return
def createExt4ConversionJob(self):
if not isFileSystemSupported('ext4'):
raise Exception, _('You system does not support ext4')
job = Task.Job(_('Convert ext3 to ext4...'))
if not path.exists('/sbin/tune2fs'):
task = Task.LoggingTask(job, 'update packages')
task.setTool('opkg')
task.args.append('update')
task = Task.LoggingTask(job, 'Install e2fsprogs-tune2fs')
task.setTool('opkg')
task.args.append('install')
task.args.append('e2fsprogs-tune2fs')
if self.findMount():
UnmountTask(job, self)
dev = self.mount_device
else:
dev = self.partitionPath('1')
task = Task.LoggingTask(job, 'fsck')
task.setTool('fsck.ext3')
task.args.append('-p')
task.args.append(dev)
task = Task.LoggingTask(job, 'tune2fs')
task.setTool('tune2fs')
task.args.append('-O')
task.args.append('extents,uninit_bg,dir_index')
task.args.append('-o')
task.args.append('journal_data_writeback')
task.args.append(dev)
task = Task.LoggingTask(job, 'fsck')
task.setTool('fsck.ext4')
task.postconditions = []
task.args.append('-f')
task.args.append('-p')
task.args.append('-D')
task.args.append(dev)
MountTask(job, self)
task = Task.ConditionTask(job, _('Wait for mount'))
task.check = self.mountDevice
return job
def exec_rule(self):
if not getattr(self,'rule',None):
return
try:
self.meths.remove('apply_core')
except ValueError:
pass
func=self.rule
vars2=[]
if isinstance(func,str):
(func,vars2)=Task.compile_fun('',self.rule,shell=getattr(self,'shell',True))
func.code=self.rule
vars=getattr(self,'vars',vars2)
if not vars:
if isinstance(self.rule,str):
vars=self.rule
else:
vars=Utils.h_fun(self.rule)
name=getattr(self,'name',None)or self.target or self.rule
cls=Task.task_type_from_func(name,func,vars)
tsk=self.create_task(name)
if getattr(self,'target',None):
cls.quiet=True
tsk.outputs=[self.path.find_or_declare(x)for x in self.to_list(self.target)]
if getattr(self,'source',None):
cls.quiet=True
tsk.inputs=[]
for x in self.to_list(self.source):
y=self.path.find_resource(x)
if not y:
raise Utils.WafError('input file %r could not be found (%r)'%(x,self.path.abspath()))
tsk.inputs.append(y)
if getattr(self,'always',None):
Task.always_run(cls)
if getattr(self,'scan',None):
cls.scan=self.scan
if getattr(self,'install_path',None):
tsk.install_path=self.install_path
if getattr(self,'cwd',None):
tsk.cwd=self.cwd
if getattr(self,'on_results',None):
Task.update_outputs(cls)
for x in['after','before']:
setattr(cls,x,getattr(self,x,[]))
def process_request(self, request, client_address):
"""Start a new thread to process the request."""
if self.useThread:
if self.threadPool:
self.logger.debug("Handing off request %s to threadpool." % (
str(client_address)))
# If there is a threadpool with worker tasks, use it
task = Task.FuncTask2(self.fn, request, client_address)
task.initialize(self)
self.threadPool.addTask(task)
else:
self.logger.debug("Creating thread to handle request %s." % (
str(client_address)))
# otherwise create a new thread
t = threading.Thread(target=self.fn,
args=(request, client_address))
if self.daemon_threads:
t.setDaemon(1)
t.start()
# Default behavior is single-threaded sequential execution
else:
self.fn(request, client_address)
def run_optimize(sort_tasks):
t = tsk.Task("", 0, 0, 0, 0)
dtime = sort_tasks[len(sort_tasks) -
1].start + sort_tasks[len(sort_tasks) - 1].length
for i in range(0, len(sort_tasks) - 1):
index = len(sort_tasks) - 1 - i
for j in range(0, len(sort_tasks) - 1 - i):
if (sort_tasks[j].deadline >= dtime) and (
sort_tasks[j].length < sort_tasks[index].length):
index = j
if index != (len(sort_tasks) - 1 - i):
t.length = sort_tasks[len(sort_tasks) - 1 - i].length
t.title = sort_tasks[len(sort_tasks) - 1 - i].title
t.deadline = sort_tasks[len(sort_tasks) - 1 - i].deadline
sort_tasks[len(sort_tasks) - 1 -
i].length = sort_tasks[index].length
sort_tasks[len(sort_tasks) - 1 - i].title = sort_tasks[index].title
sort_tasks[len(sort_tasks) - 1 -
i].deadline = sort_tasks[index].deadline
sort_tasks[index].length = t.length
sort_tasks[index].title = t.title
sort_tasks[index].deadline = t.deadline
dtime = dtime - sort_tasks[len(sort_tasks) - 1 - i].length
for i in range(0, len(sort_tasks) - 1):
if i == 0:
sort_tasks[i].start = dtime - sort_tasks[i].length
else:
sort_tasks[i].start = sort_tasks[i -
1].start + sort_tasks[i -
1].length
return sort_tasks
def workThread(self,client):
sl = SocketStreamReader(client)
while True:
msg = sl.readline()
msg = msg.decode("utf-8")
try:
msg = json.loads(msg)
No = msg["No"]
id = msg["taskId"]
if(No=="submit"):
t = Task(id)
self.tm.addTask(t)
elif(No=="GetData"):
line = self.tm.getCureveData(id,msg["pos"])
client.send((line+'\n').encode("utf-8"))
else:
mode = msg["mode"]
if(mode=="start"):
print("start")
self.tm.startTask(id)
elif(mode=="suspend"):
print("suspend")
self.tm.suspendTask(id)
elif(mode=="goon"):
print("goon")
self.tm.goonTask(id)
elif(mode=="stop"):
print("stop")
self.tm.stopTask(id)
elif(mode=="restart"):
print("restart")
self.tm.restartTask(id)
except Exception:
val = traceback.format_exc()
print(val)
def __init__(self):
# get tasktable for administrating tasks
self.taskTable = Task.TaskTable()
handlers = [
(r"/", ClassifierHandler),
(r"/format/(\w+)", DataFormatHandler),
(r"/result/(\w+).(\w+)", ResultDataHandler),
(r"/delete", DeleteHandler),
(r"/stat_feature", StatFeatureHandler),
(r"/rbf_gamma", RBFGammaHandler),
(r"/soft_margin", SoftMarginHandler),
(r"/forward_stepwise", ForwardStepwiseHandler),
(r"/state/(\w+)", StateHandler),
(r"/knn", KnnHandler)
]
settings = {
'template_path': 'templates',
'static_path': 'static',
'debug': 'True'
}
tornado.web.Application.__init__(self, handlers, **settings)
def eventAbduction(compoundTask, componentTask):
# TODO< assert on types of task >
resultTaskStamp = Stamp.merge(compoundTask.stamp, componentTask.stamp)
resultTask = Task(Task.ENUMTYPE_GOAL, resultTaskStamp)
resultTask.sdr = sdrDetachmentForward(compoundTask.sdr, componentTask.sdr)
resultTask.identifyingSdr = resultTask.sdr # we do this because they are the same for NARS tasks!
resultTask.truth = TruthValue.abduction(compoundTask.truth,
componentTask.truth)
resultTask.attention = AttentionValue()
if DEBUG:
## TODO< used debug cookie of name of SDR if possible >
print("[t] event ABDUCTION {{{}., {}!}} |- {}!".format(
compoundTask.retHumanReadableId(),
componentTask.retHumanReadableId(),
resultTask.sdr.retHumanReadableId()))
return resultTask
def parseCommands(self, r):
tasks=Task.TaskGroup()
for c in r.getchildren():
#
# <message>
if c.tag == 'message': # end message
sendto = c.get('sendto')
if not sendto : sendto = c.get('host')
task = Task.TaskMessage(self.parent, sendto, c.text, c.get('encode'), c.get('input'))
tasks.addTask(task)
#
# <statetransition>
elif c.tag == 'statetransition': # get statetransition
task = Task.TaskStatetransition(self.parent, c.get('func'), c.text)
tasks.addTask(task)
#
# <log>
elif c.tag == 'log': # logging
task = Task.TaskLog(self.parent, c.text)
tasks.addTask(task)
#
# <shell>
elif c.tag == 'shell': # get shell
sendto = c.get('sendto')
if not sendto : sendto = c.get('host')
task = Task.TaskShell(self.parent, sendto, c.text)
tasks.addTask(task)
#
# <script>
elif c.tag == 'script': # get script
sendto = c.get('sendto')
if not sendto : sendto = c.get('host')
task = Task.TaskScript(self.parent, sendto,
self.getScripts(c), c.get('execfile'), c.get('import'))
tasks.addTask(task)
return tasks
def processTask(self, data):
"""
This function determines which task is being asked to run on the robot
and calls the apprropriate task function. It also adds the task to the
active task list if a robot is assigned, or a priority queue if no robot
is assigned. Please look at the task code data structure above to see what that task codes mean.
:param data: the string containing the robot and task information.
i.e. <task name> <robot name> <X coordinate> <Y coordinate>
:return None
"""
# Have to know if the task has been unnassigned
# have to know what the task is
# Task Strings: 'task_name robot_name X Y [vars ...]'
# DLV vars = fromX fromY
if type(data) == str:
dataList = data.split()
if (data == ""):
return
else:
if(data.data == ""):
return
dataList = data.data.split()
supervisorID = dataList[0]
supervisor = self.activeSupervisorDictionary[supervisorID]
taskName = dataList[1]
# passed as unassigned if task is not assigned
robotName = dataList[2]
yaw = -float(dataList[5]) + np.pi
raisePriority = dataList[6]
if (raisePriority == "False"):
priorityRaised = False
else:
priorityRaised = True
print('Split Task Data')
print("PRIORITY RAISED: ", priorityRaised)
print(len(dataList))
print(dataList)
# if len(dataList) > 5:
# variables = dataList[5]
# else:
# variables = " "
if (taskName != 'SOS'):
X = float(dataList[3])
Y = float(dataList[4])
newTask = Task(taskName, self.taskPrios[taskName], robotName, X, Y, yaw, priorityRaised, supervisorID)
newTaskMsg = newTask.convertTaskToTaskMsg()
if robotName != "unassigned":
# remove current task form active task list
oldTaskMsg = self.activeRobotDictionary[robotName].currentTask
for task in supervisor.activeTaskList:
if oldTaskMsg.ID == task.getID():
supervisor.activeTaskList.remove(task)
break
self.taskFns[taskName](newTaskMsg)
supervisor.activeTaskList.append(newTask)
else:
supervisor.taskPriorityQueue.append(newTask)
supervisor.taskPriorityQueue.sort(key=lambda task: task.getPriority())
print('Called Task Function')
elif (taskName == 'SOS'):
self.passRobotToQueueForOperator(robotName)
mode = '2'
debug('msvc: embedding manifest')
lst = []
lst.extend(Utils.to_list(env['MT']))
lst.extend(Utils.to_list(env['MTFLAGS']))
lst.extend(Utils.to_list("-manifest"))
lst.extend(Utils.to_list(manifest))
lst.extend(Utils.to_list("-outputresource:%s;%s" % (outfile, mode)))
lst = [lst]
return self.exec_command(*lst)
return None
cls = Task.task_type_from_func('msvc_manifest',
vars=['MT', 'MTFLAGS'],
color='BLUE',
func=exec_mf,
ext_in='.bin')
cls.quiet = 1
def exec_command_msvc(self, *k, **kw):
if self.env['CC_NAME'] == 'msvc':
if isinstance(k[0], list):
lst = []
carry = ''
for a in k[0]:
if len(a) == 3 and a.startswith(
'/F') or a == '/doc' or a[-1] == ':':
carry = a
else:
def createInitializeJob(self):
job = Task.Job(_("Initializing storage device..."))
size = self.diskSize()
print "[HD] size: %s MB" % size
task = UnmountTask(job, self)
task = Task.PythonTask(job, _("Removing partition table"))
task.work = self.killPartitionTable
task.weighting = 1
task = Task.LoggingTask(job, _("Rereading partition table"))
task.weighting = 1
task.setTool('hdparm')
task.args.append('-z')
task.args.append(self.disk_path)
task = Task.ConditionTask(job, _("Waiting for partition"), timeoutCount=20)
task.check = lambda: not os.path.exists(self.partitionPath("1"))
task.weighting = 1
if os.path.exists('/usr/sbin/parted'):
use_parted = True
else:
if size > 2097151:
addInstallTask(job, 'parted')
use_parted = True
else:
use_parted = False
task = Task.LoggingTask(job, _("Creating partition"))
task.weighting = 5
if use_parted:
task.setTool('parted')
if size < 1024:
# On very small devices, align to block only
alignment = 'min'
else:
# Prefer optimal alignment for performance
alignment = 'opt'
if size > 2097151:
parttype = 'gpt'
else:
parttype = 'msdos'
task.args += ['-a', alignment, '-s', self.disk_path, 'mklabel', parttype, 'mkpart', 'primary', '0%', '100%']
else:
task.setTool('sfdisk')
task.args.append('-f')
task.args.append('-uS')
task.args.append(self.disk_path)
if size > 128000:
# Start at sector 8 to better support 4k aligned disks
print "[HD] Detected >128GB disk, using 4k alignment"
task.initial_input = "8,\n;0,0\n;0,0\n;0,0\ny\n"
else:
# Smaller disks (CF cards, sticks etc) don't need that
task.initial_input = "0,\n;\n;\n;\ny\n"
task = Task.ConditionTask(job, _("Waiting for partition"))
task.check = lambda: os.path.exists(self.partitionPath("1"))
task.weighting = 1
task = MkfsTask(job, _("Creating filesystem"))
big_o_options = ["dir_index"]
if isFileSystemSupported("ext4"):
task.setTool("mkfs.ext4")
if size > 20000:
try:
file = open("/proc/version","r")
version = map(int, file.read().split(' ', 4)[2].split('.',2)[:2])
file.close()
if (version[0] > 3) or (version[0] > 2 and version[1] >= 2):
# Linux version 3.2 supports bigalloc and -C option, use 256k blocks
task.args += ["-C", "262144"]
big_o_options.append("bigalloc")
except Exception, ex:
print "Failed to detect Linux version:", ex
# No more than 256k i-nodes (prevent problems with fsck memory requirements)
task.args += ["-T", "largefile", "-N", "262144"]
big_o_options.append("sparse_super")
elif size > 16384:
# between 16GB and 250GB: 1 i-node per megabyte
task.args += ["-T", "largefile"]
big_o_options.append("sparse_super")
elif size > 2048:
# Over 2GB: 32 i-nodes per megabyte
task.args += ["-T", "largefile", "-N", str(size * 32)]
task.args += ["-m0", "-O", ",".join(big_o_options), self.partitionPath("1")]
task = MountTask(job, self)
task.weighting = 3
task = Task.ConditionTask(job, _("Waiting for mount"), timeoutCount=20)
task.check = self.mountDevice
task.weighting = 1
return job
def initialize(self):
# no longer supported
return -5
def check(self):
# no longer supported
return -5
def createCheckJob(self):
job = Task.Job(_("Checking filesystem..."))
elif size > 16384:
# between 16GB and 250GB: 1 i-node per megabyte
task.args += ["-T", "largefile"]
big_o_options.append("sparse_super")
elif size > 2048:
# Over 2GB: 32 i-nodes per megabyte
task.args += ["-T", "largefile", "-N", str(size * 32)]
task.args += [
"-m0", "-O", ",".join(big_o_options),
self.partitionPath("1")
]
task = MountTask(job, self)
task.weighting = 3
task = Task.ConditionTask(job, _("Waiting for mount"), timeoutCount=20)
task.check = self.mountDevice
task.weighting = 1
task = Task.PythonTask(job, _("Create directory") + ": movie")
task.work = self.createMovieDir
task.weighting = 1
return job
def initialize(self):
# no longer supported
return -5
def check(self):
# no longer supported
dep.post()
for dep_task in dep.tasks:
task.set_run_after(dep_task)
if not task.inputs:
task.runnable_status = type(Task.TaskBase.run)(runnable_status, task,
task.__class__)
task.post_run = type(Task.TaskBase.run)(post_run, task, task.__class__)
def post_run(self):
for x in self.outputs:
h = Utils.h_file(x.abspath(self.env))
self.generator.bld.node_sigs[self.env.variant()][x.id] = h
def runnable_status(self):
return Constants.RUN_ME
Task.task_type_from_func('copy', vars=[], func=action_process_file_func)
TaskGen.task_gen.classes['command-output'] = cmd_output_taskgen
feature('cmd')(apply_cmd)
feature('copy')(apply_copy)
before('apply_core')(apply_copy)
feature('subst')(apply_subst)
before('apply_core')(apply_subst)
feature('command-output')(init_cmd_output)
feature('command-output')(apply_cmd_output)
after('init_cmd_output')(apply_cmd_output)
def createInitializeJob(self):
job = Task.Job(_("Initializing storage device..."))
size = self.diskSize()
print "[HD] size: %s MB" % size
task = UnmountTask(job, self)
task = Task.PythonTask(job, _("Removing partition table"))
task.work = self.killPartitionTable
task.weighting = 1
task = Task.LoggingTask(job, _("Rereading partition table"))
task.weighting = 1
task.setTool('hdparm')
task.args.append('-z')
task.args.append(self.disk_path)
task = Task.ConditionTask(job,
_("Waiting for partition"),
timeoutCount=20)
task.check = lambda: not os.path.exists(self.partitionPath("1"))
task.weighting = 1
if os.path.exists('/usr/sbin/parted'):
use_parted = True
else:
if size > 2097151:
addInstallTask(job, 'parted')
use_parted = True
else:
use_parted = False
task = Task.LoggingTask(job, _("Creating partition"))
task.weighting = 5
if use_parted:
task.setTool('parted')
if size < 1024:
# On very small devices, align to block only
alignment = 'min'
else:
# Prefer optimal alignment for performance
alignment = 'opt'
if size > 2097151:
parttype = 'gpt'
else:
parttype = 'msdos'
task.args += [
'-a', alignment, '-s', self.disk_path, 'mklabel', parttype,
'mkpart', 'primary', '0%', '100%'
]
else:
task.setTool('sfdisk')
task.args.append('-f')
task.args.append('-uS')
task.args.append(self.disk_path)
if size > 128000:
# Start at sector 8 to better support 4k aligned disks
print "[HD] Detected >128GB disk, using 4k alignment"
task.initial_input = "8,\n;0,0\n;0,0\n;0,0\ny\n"
else:
# Smaller disks (CF cards, sticks etc) don't need that
task.initial_input = "0,\n;\n;\n;\ny\n"
task = Task.ConditionTask(job, _("Waiting for partition"))
task.check = lambda: os.path.exists(self.partitionPath("1"))
task.weighting = 1
task = MkfsTask(job, _("Creating filesystem"))
big_o_options = ["dir_index"]
if isFileSystemSupported("ext4"):
task.setTool("mkfs.ext4")
else:
task.setTool("mkfs.ext3")
if size > 250000:
# No more than 256k i-nodes (prevent problems with fsck memory requirements)
task.args += ["-T", "largefile", "-N", "262144"]
big_o_options.append("sparse_super")
elif size > 16384:
# between 16GB and 250GB: 1 i-node per megabyte
task.args += ["-T", "largefile"]
big_o_options.append("sparse_super")
elif size > 2048:
# Over 2GB: 32 i-nodes per megabyte
task.args += ["-T", "largefile", "-N", str(size * 32)]
task.args += [
"-m0", "-O ^metadata_csum", "-O", ",".join(big_o_options),
self.partitionPath("1")
]
task = MountTask(job, self)
task.weighting = 3
task = Task.ConditionTask(job, _("Waiting for mount"), timeoutCount=20)
task.check = self.mountDevice
task.weighting = 1
return job
add_path(fu,lst,'LD_LIBRARY_PATH')
else:
add_path(fu,lst,'LD_LIBRARY_PATH')
try:
ret=Utils.cmd_output(filename,cwd=self.inputs[0].parent.abspath(self.env),env=fu)
except Exception,e:
fail=True
ret=''+str(e)
else:
pass
stats=getattr(self.generator.bld,'utest_results',[])
stats.append((filename,fail,ret))
self.generator.bld.utest_results=stats
finally:
testlock.release()
cls=Task.task_type_from_func('utest',func=exec_test,color='RED',ext_in='.bin')
old=cls.runnable_status
def test_status(self):
if getattr(Options.options,'all_tests',False):
return RUN_ME
return old(self)
cls.runnable_status=test_status
cls.quiet=1
def summary(bld):
lst=getattr(bld,'utest_results',[])
if lst:
Utils.pprint('CYAN','execution summary')
for(f,fail,ret)in lst:
col=fail and'RED'or'GREEN'
Utils.pprint(col,(fail and'FAIL'or'ok')+" "+f)
if fail:Utils.pprint('NORMAL',ret.replace('\\n','\n'))
val = self.env['CXXDEFINES_'+l]
if val: milst += self.to_list(val)
self.env['DEFLINES'] = ["%s %s" % (x[0], Utils.trimquotes('='.join(x[1:]))) for x in [y.split('=') for y in milst]]
y = self.env['CXXDEFINES_ST']
self.env['_CXXDEFFLAGS'] = [y%x for x in milst]
@extension(EXT_CXX)
def cxx_hook(self, node):
# create the compilation task: cpp or cc
if getattr(self, 'obj_ext', None):
obj_ext = self.obj_ext
else:
obj_ext = '_%d.o' % self.idx
task = self.create_task('cxx', node, node.change_ext(obj_ext))
try:
self.compiled_tasks.append(task)
except AttributeError:
raise Utils.WafError('Have you forgotten to set the feature "cxx" on %s?' % str(self))
return task
cxx_str = '${CXX} ${CXXFLAGS} ${CPPFLAGS} ${_CXXINCFLAGS} ${_CXXDEFFLAGS} ${CXX_SRC_F}${SRC} ${CXX_TGT_F}${TGT}'
cls = Task.simple_task_type('cxx', cxx_str, color='GREEN', ext_out='.o', ext_in='.cxx', shell=False)
cls.scan = ccroot.scan
cls.vars.append('CXXDEPS')
link_str = '${LINK_CXX} ${CXXLNK_SRC_F}${SRC} ${CXXLNK_TGT_F}${TGT[0].abspath(env)} ${LINKFLAGS}'
cls = Task.simple_task_type('cxx_link', link_str, color='YELLOW', ext_in='.o', ext_out='.bin', shell=False)
cls.maxjobs = 1
cls.install = Utils.nada