"""

import sys

import traceback

tb = sys.exc_info()[2]

while 1:

if not tb.tb_next:

break

tb = tb.tb_next

stack = []

f = tb.tb_frame

while f:

stack.append(f)

f = f.f_back

stack.reverse()

traceback.print_exc()

print("Locals by frame, innermost last")

for frame in stack:

print("")

print("Frame %s in %s at line %s" % (frame.f_code.co_name,

frame.f_code.co_filename,

frame.f_lineno))

for key, value in list(frame.f_locals.items()):

#We have to be careful not to cause a new error in our error

#printer! Calling str() on an unknown object could cause an

#error we don't want.

try:

valueStr = str(value)

except:

valueStr = "<ERROR WHILE PRINTING VALUE>"

seq = AsyncTaskSequence('sequence')

for task in taskList:

seq.addTask(task)

seq = AsyncTaskSequence('loop')

for task in taskList:

seq.addTask(task)

seq.setRepeatCount(-1)

notify = directNotify.newCategory("TaskManager")

taskTimerVerbose = ConfigVariableBool('task-timer-verbose', False)

extendedExceptions = ConfigVariableBool('extended-exceptions', False)

pStatsTasks = ConfigVariableBool('pstats-tasks', False)

MaxEpochSpeed = 1.0/30.0

def __init__(self):

self.mgr = AsyncTaskManager.getGlobalPtr()

self.resumeFunc = None

self.globalClock = self.mgr.getClock()

self.stepping = False

self.running = False

self.destroyed = False

self.fKeyboardInterrupt = False

self.interruptCount = 0

self._frameProfileQueue = Queue()

# this will be set when it's safe to import StateVar

self._profileFrames = None

self._frameProfiler = None

self._profileTasks = None

self._taskProfiler = None

self._taskProfileInfo = ScratchPad(

taskId = None,

profiled = False,

session = None,

)

def finalInit(self):

# This function should be called once during startup, after

# most things are imported.

from direct.fsm.StatePush import StateVar

self._profileTasks = StateVar(False)

self.setProfileTasks(ConfigVariableBool('profile-task-spikes', 0).getValue())

self._profileFrames = StateVar(False)

self.setProfileFrames(ConfigVariableBool('profile-frames', 0).getValue())

def destroy(self):

# This should be safe to call multiple times.

self.running = False

self.notify.info("TaskManager.destroy()")

self.destroyed = True

self._frameProfileQueue.clear()

self.mgr.cleanup()

def setClock(self, clockObject):

self.mgr.setClock(clockObject)

self.globalClock = clockObject

clock = property(lambda self: self.mgr.getClock(), setClock)

def invokeDefaultHandler(self, signalNumber, stackFrame):

print('*** allowing mid-frame keyboard interrupt.')

# Restore default interrupt handler

if signal:

signal.signal(signal.SIGINT, signal.default_int_handler)

# and invoke it

raise KeyboardInterrupt

def keyboardInterruptHandler(self, signalNumber, stackFrame):

self.fKeyboardInterrupt = 1

self.interruptCount += 1

if self.interruptCount == 1:

print('* interrupt by keyboard')

elif self.interruptCount == 2:

print('** waiting for end of frame before interrupting...')

# The user must really want to interrupt this process

# Next time around invoke the default handler

signal.signal(signal.SIGINT, self.invokeDefaultHandler)

def getCurrentTask(self):

""" Returns the task currently executing on this thread, or

return Thread.getCurrentThread().getCurrentTask()

def hasTaskChain(self, chainName):

""" Returns true if a task chain with the indicated name has

return (self.mgr.findTaskChain(chainName) != None)

def setupTaskChain(self, chainName, numThreads = None, tickClock = None,

threadPriority = None, frameBudget = None,

frameSync = None, timeslicePriority = None):

"""Defines a new task chain. Each task chain executes tasks

chain = self.mgr.makeTaskChain(chainName)

if numThreads is not None:

chain.setNumThreads(numThreads)

if tickClock is not None:

chain.setTickClock(tickClock)

if threadPriority is not None:

chain.setThreadPriority(threadPriority)

if frameBudget is not None:

chain.setFrameBudget(frameBudget)

if frameSync is not None:

chain.setFrameSync(frameSync)

if timeslicePriority is not None:

chain.setTimeslicePriority(timeslicePriority)

def hasTaskNamed(self, taskName):

"""Returns true if there is at least one task, active or

return bool(self.mgr.findTask(taskName))

def getTasksNamed(self, taskName):

"""Returns a list of all tasks, active or sleeping, with the

return self.__makeTaskList(self.mgr.findTasks(taskName))

def getTasksMatching(self, taskPattern):

"""Returns a list of all tasks, active or sleeping, with a

return self.__makeTaskList(self.mgr.findTasksMatching(GlobPattern(taskPattern)))

def getAllTasks(self):

"""Returns list of all tasks, active and sleeping, in

return self.__makeTaskList(self.mgr.getTasks())

def getTasks(self):

"""Returns list of all active tasks in arbitrary order. """

return self.__makeTaskList(self.mgr.getActiveTasks())

def getDoLaters(self):

"""Returns list of all sleeping tasks in arbitrary order. """

return self.__makeTaskList(self.mgr.getSleepingTasks())

def __makeTaskList(self, taskCollection):

l = []

for i in range(taskCollection.getNumTasks()):

l.append(taskCollection.getTask(i))

return l

def doMethodLater(self, delayTime, funcOrTask, name, extraArgs = None,

sort = None, priority = None, taskChain = None,

uponDeath = None, appendTask = False, owner = None):

"""Adds a task to be performed at some time in the future.

if delayTime < 0:

assert self.notify.warning('doMethodLater: added task: %s with negative delay: %s' % (name, delayTime))

task = self.__setupTask(funcOrTask, name, priority, sort, extraArgs, taskChain, appendTask, owner, uponDeath)

task.setDelay(delayTime)

self.mgr.add(task)

return task

do_method_later = doMethodLater

def add(self, funcOrTask, name = None, sort = None, extraArgs = None,

priority = None, uponDeath = None, appendTask = False,

taskChain = None, owner = None):

"""

task = self.__setupTask(funcOrTask, name, priority, sort, extraArgs, taskChain, appendTask, owner, uponDeath)

self.mgr.add(task)

return task

def __setupTask(self, funcOrTask, name, priority, sort, extraArgs, taskChain, appendTask, owner, uponDeath):

if isinstance(funcOrTask, AsyncTask):

task = funcOrTask

elif hasattr(funcOrTask, '__call__') or \

hasattr(funcOrTask, 'cr_await') or \

type(funcOrTask) == types.GeneratorType:

# It's a function, coroutine, or something emulating a coroutine.

task = PythonTask(funcOrTask)

if name is None:

name = getattr(funcOrTask, '__qualname__', None) or \

getattr(funcOrTask, '__name__', None)

else:

self.notify.error(

'add: Tried to add a task that was not a Task or a func')

if hasattr(task, 'setArgs'):

# It will only accept arguments if it's a PythonTask.

if extraArgs is None:

extraArgs = []

appendTask = True

task.setArgs(extraArgs, appendTask)

elif extraArgs is not None:

self.notify.error(

'Task %s does not accept arguments.' % (repr(task)))

if name is not None:

task.setName(name)

assert task.hasName()

# For historical reasons, if priority is specified but not

# sort, it really means sort.

if priority is not None and sort is None:

task.setSort(priority)

else:

if priority is not None:

task.setPriority(priority)

if sort is not None:

task.setSort(sort)

if taskChain is not None:

task.setTaskChain(taskChain)

if owner is not None:

task.setOwner(owner)

if uponDeath is not None:

task.setUponDeath(uponDeath)

return task

def remove(self, taskOrName):

"""Removes a task from the task manager. The task is stopped,

if isinstance(taskOrName, AsyncTask):

return self.mgr.remove(taskOrName)

elif isinstance(taskOrName, list):

for task in taskOrName:

self.remove(task)

else:

tasks = self.mgr.findTasks(taskOrName)

return self.mgr.remove(tasks)

def removeTasksMatching(self, taskPattern):

"""Removes all tasks whose names match the pattern, which can

tasks = self.mgr.findTasksMatching(GlobPattern(taskPattern))

return self.mgr.remove(tasks)

def step(self):

"""Invokes the task manager for one frame, and then returns.

# Replace keyboard interrupt handler during task list processing

# so we catch the keyboard interrupt but don't handle it until

# after task list processing is complete.

self.fKeyboardInterrupt = 0

self.interruptCount = 0

if signal:

signal.signal(signal.SIGINT, self.keyboardInterruptHandler)

startFrameTime = self.globalClock.getRealTime()

self.mgr.poll()

# This is the spot for an internal yield function

nextTaskTime = self.mgr.getNextWakeTime()

self.doYield(startFrameTime, nextTaskTime)

# Restore default interrupt handler

if signal:

signal.signal(signal.SIGINT, signal.default_int_handler)

if self.fKeyboardInterrupt:

raise KeyboardInterrupt

def run(self):

"""Starts the task manager running. Does not return until an

if PandaSystem.getPlatform() == 'emscripten':

return

# Set the clock to have last frame's time in case we were

# Paused at the prompt for a long time

t = self.globalClock.getFrameTime()

timeDelta = t - self.globalClock.getRealTime()

self.globalClock.setRealTime(t)

messenger.send("resetClock", [timeDelta])

if self.resumeFunc != None:

self.resumeFunc()

if self.stepping:

self.step()

else:

self.running = True

while self.running:

try:

if len(self._frameProfileQueue):

numFrames, session, callback = self._frameProfileQueue.pop()

def _profileFunc(numFrames=numFrames):

self._doProfiledFrames(numFrames)

session.setFunc(_profileFunc)

session.run()

_profileFunc = None

if callback:

callback()

session.release()

else:

self.step()

except KeyboardInterrupt:

self.stop()

except SystemExit:

self.stop()

raise

except IOError as ioError:

code, message = self._unpackIOError(ioError)

# Since upgrading to Python 2.4.1, pausing the execution

# often gives this IOError during the sleep function:

# IOError: [Errno 4] Interrupted function call

# So, let's just handle that specific exception and stop.

# All other IOErrors should still get raised.

# Only problem: legit IOError 4s will be obfuscated.

if code == 4:

self.stop()

else:

raise

except Exception as e:

if self.extendedExceptions:

self.stop()

print_exc_plus()

else:

if (ExceptionVarDump.wantStackDumpLog and

ExceptionVarDump.dumpOnExceptionInit):

ExceptionVarDump._varDump__print(e)

raise

except:

if self.extendedExceptions:

self.stop()

print_exc_plus()

else:

raise

self.mgr.stopThreads()

def _unpackIOError(self, ioError):

# IOError unpack from http://www.python.org/doc/essays/stdexceptions/

# this needs to be in its own method, exceptions that occur inside

# a nested try block are not caught by the inner try block's except

try:

(code, message) = ioError

except:

code = 0

message = ioError

return code, message

def stop(self):

# Set a flag so we will stop before beginning next frame

self.running = False

def __tryReplaceTaskMethod(self, task, oldMethod, newFunction):

if not isinstance(task, PythonTask):

return 0

method = task.getFunction()

if (type(method) == types.MethodType):

function = method.__func__

else:

function = method

if (function == oldMethod):

newMethod = types.MethodType(newFunction,

method.__self__,

method.__self__.__class__)

task.setFunction(newMethod)

# Found a match

return 1

return 0

def replaceMethod(self, oldMethod, newFunction):

numFound = 0

for task in self.getAllTasks():

numFound += self.__tryReplaceTaskMethod(task, oldMethod, newFunction)

return numFound

def popupControls(self):

# Don't use a regular import, to prevent ModuleFinder from picking

# it up as a dependency when building a .p3d package.

TaskManagerPanel = importlib.import_module('direct.tkpanels.TaskManagerPanel')

return TaskManagerPanel.TaskManagerPanel(self)

def getProfileSession(self, name=None):

# call to get a profile session that you can modify before passing to profileFrames()

if name is None:

name = 'taskMgrFrameProfile'

# Defer this import until we need it: some Python

# distributions don't provide the profile and pstats modules.

PS = importlib.import_module('direct.showbase.ProfileSession')

return PS.ProfileSession(name)

def profileFrames(self, num=None, session=None, callback=None):

if num is None:

num = 1

if session is None:

session = self.getProfileSession()

# make sure the profile session doesn't get destroyed before we're done with it

session.acquire()

self._frameProfileQueue.push((num, session, callback))

def _doProfiledFrames(self, numFrames):

for i in range(numFrames):

result = self.step()

return result

def getProfileFrames(self):

return self._profileFrames.get()

def getProfileFramesSV(self):

return self._profileFrames

def setProfileFrames(self, profileFrames):

self._profileFrames.set(profileFrames)

if (not self._frameProfiler) and profileFrames:

# import here due to import dependencies

FP = importlib.import_module('direct.task.FrameProfiler')

self._frameProfiler = FP.FrameProfiler()

def getProfileTasks(self):

return self._profileTasks.get()

def getProfileTasksSV(self):

return self._profileTasks

def setProfileTasks(self, profileTasks):

self._profileTasks.set(profileTasks)

if (not self._taskProfiler) and profileTasks:

# import here due to import dependencies

TP = importlib.import_module('direct.task.TaskProfiler')

self._taskProfiler = TP.TaskProfiler()

def logTaskProfiles(self, name=None):

if self._taskProfiler:

self._taskProfiler.logProfiles(name)

def flushTaskProfiles(self, name=None):

if self._taskProfiler:

self._taskProfiler.flush(name)

def _setProfileTask(self, task):

if self._taskProfileInfo.session:

self._taskProfileInfo.session.release()

self._taskProfileInfo.session = None

self._taskProfileInfo = ScratchPad(

taskFunc = task.getFunction(),

taskArgs = task.getArgs(),

task = task,

profiled = False,

session = None,

)

# Temporarily replace the task's own function with our

# _profileTask method.

task.setFunction(self._profileTask)

task.setArgs([self._taskProfileInfo], True)

def _profileTask(self, profileInfo, task):

# This is called instead of the task function when we have

# decided to profile a task.

assert profileInfo.task == task

# don't profile the same task twice in a row

assert not profileInfo.profiled

# Restore the task's proper function for next time.

appendTask = False

taskArgs = profileInfo.taskArgs

if taskArgs and taskArgs[-1] == task:

appendTask = True

taskArgs = taskArgs[:-1]

task.setArgs(taskArgs, appendTask)

task.setFunction(profileInfo.taskFunc)

# Defer this import until we need it: some Python

# distributions don't provide the profile and pstats modules.

PS = importlib.import_module('direct.showbase.ProfileSession')

profileSession = PS.ProfileSession('profiled-task-%s' % task.getName(),

Functor(profileInfo.taskFunc, *profileInfo.taskArgs))

ret = profileSession.run()

# set these values *after* profiling in case we're profiling the TaskProfiler

profileInfo.session = profileSession

profileInfo.profiled = True

return ret

def _hasProfiledDesignatedTask(self):

# have we run a profile of the designated task yet?

return self._taskProfileInfo.profiled

def _getLastTaskProfileSession(self):

return self._taskProfileInfo.session

def _getRandomTask(self):

# Figure out when the next frame is likely to expire, so we

# won't grab any tasks that are sleeping for a long time.

now = self.globalClock.getFrameTime()

avgFrameRate = self.globalClock.getAverageFrameRate()

if avgFrameRate < .00001:

avgFrameDur = 0.

else:

avgFrameDur = (1. / self.globalClock.getAverageFrameRate())

next = now + avgFrameDur

# Now grab a task at random, until we find one that we like.

tasks = self.mgr.getTasks()

i = random.randrange(tasks.getNumTasks())

task = tasks.getTask(i)

while not isinstance(task, PythonTask) or \

task.getWakeTime() > next:

tasks.removeTask(i)

i = random.randrange(tasks.getNumTasks())

task = tasks.getTask(i)

return task

def __repr__(self):

return str(self.mgr)

# In the event we want to do frame time managment, this is the

# function to replace or overload.

def doYield(self, frameStartTime, nextScheduledTaskTime):

pass

"""

if __debug__:

# to catch memory leaks during the tests at the bottom of the file

def _startTrackingMemLeaks(self):

pass

def _stopTrackingMemLeaks(self):

pass

def _checkMemLeaks(self):

pass

def _runTests(self):

if __debug__:

tm = TaskManager()

tm.setClock(ClockObject())

tm.setupTaskChain("default", tickClock = True)

# check for memory leaks after every test

tm._startTrackingMemLeaks()

tm._checkMemLeaks()

# run-once task

l = []

def _testDone(task, l=l):

l.append(None)

return task.done

tm.add(_testDone, 'testDone')

tm.step()

assert len(l) == 1

tm.step()

assert len(l) == 1

_testDone = None

tm._checkMemLeaks()

# remove by name

def _testRemoveByName(task):

return task.done

tm.add(_testRemoveByName, 'testRemoveByName')

assert tm.remove('testRemoveByName') == 1

assert tm.remove('testRemoveByName') == 0

_testRemoveByName = None

tm._checkMemLeaks()

# duplicate named tasks

def _testDupNamedTasks(task):

return task.done

tm.add(_testDupNamedTasks, 'testDupNamedTasks')

tm.add(_testDupNamedTasks, 'testDupNamedTasks')

assert tm.remove('testRemoveByName') == 0

_testDupNamedTasks = None

tm._checkMemLeaks()

# continued task

l = []

def _testCont(task, l = l):

l.append(None)

return task.cont

tm.add(_testCont, 'testCont')

tm.step()

assert len(l) == 1

tm.step()

assert len(l) == 2

tm.remove('testCont')

_testCont = None

tm._checkMemLeaks()

# continue until done task

l = []

def _testContDone(task, l = l):

l.append(None)

if len(l) >= 2:

return task.done

else:

return task.cont

tm.add(_testContDone, 'testContDone')

tm.step()

assert len(l) == 1

tm.step()

assert len(l) == 2

tm.step()

assert len(l) == 2

assert not tm.hasTaskNamed('testContDone')

_testContDone = None

tm._checkMemLeaks()

# hasTaskNamed

def _testHasTaskNamed(task):

return task.done

tm.add(_testHasTaskNamed, 'testHasTaskNamed')

assert tm.hasTaskNamed('testHasTaskNamed')

tm.step()

assert not tm.hasTaskNamed('testHasTaskNamed')

_testHasTaskNamed = None

tm._checkMemLeaks()

# task sort

l = []

def _testPri1(task, l = l):

l.append(1)

return task.cont

def _testPri2(task, l = l):

l.append(2)

return task.cont

tm.add(_testPri1, 'testPri1', sort = 1)

tm.add(_testPri2, 'testPri2', sort = 2)

tm.step()

assert len(l) == 2

assert l == [1, 2,]

tm.step()

assert len(l) == 4

assert l == [1, 2, 1, 2,]

tm.remove('testPri1')

tm.remove('testPri2')

_testPri1 = None

_testPri2 = None

tm._checkMemLeaks()

# task extraArgs

l = []

def _testExtraArgs(arg1, arg2, l=l):

l.extend([arg1, arg2,])

return done

tm.add(_testExtraArgs, 'testExtraArgs', extraArgs=[4,5])

tm.step()

assert len(l) == 2

assert l == [4, 5,]

_testExtraArgs = None

tm._checkMemLeaks()

# task appendTask

l = []

def _testAppendTask(arg1, arg2, task, l=l):

l.extend([arg1, arg2,])

return task.done

tm.add(_testAppendTask, '_testAppendTask', extraArgs=[4,5], appendTask=True)

tm.step()

assert len(l) == 2

assert l == [4, 5,]

_testAppendTask = None

tm._checkMemLeaks()

# task uponDeath

l = []

def _uponDeathFunc(task, l=l):

l.append(task.name)

def _testUponDeath(task):

return done

tm.add(_testUponDeath, 'testUponDeath', uponDeath=_uponDeathFunc)

tm.step()

assert len(l) == 1

assert l == ['testUponDeath']

_testUponDeath = None

_uponDeathFunc = None

tm._checkMemLeaks()

# task owner

class _TaskOwner:

def _addTask(self, task):

self.addedTaskName = task.name

def _clearTask(self, task):

self.clearedTaskName = task.name

to = _TaskOwner()

l = []

def _testOwner(task):

return done

tm.add(_testOwner, 'testOwner', owner=to)

tm.step()

assert getattr(to, 'addedTaskName', None) == 'testOwner'

assert getattr(to, 'clearedTaskName', None) == 'testOwner'

_testOwner = None

del to

_TaskOwner = None

tm._checkMemLeaks()

doLaterTests = [0,]

# doLater

l = []

def _testDoLater1(task, l=l):

l.append(1)

def _testDoLater2(task, l=l):

l.append(2)

def _monitorDoLater(task, tm=tm, l=l, doLaterTests=doLaterTests):

if task.time > .03:

assert l == [1, 2,]

doLaterTests[0] -= 1

return task.done

return task.cont

tm.doMethodLater(.01, _testDoLater1, 'testDoLater1')

tm.doMethodLater(.02, _testDoLater2, 'testDoLater2')

doLaterTests[0] += 1

# make sure we run this task after the doLaters if they all occur on the same frame

tm.add(_monitorDoLater, 'monitorDoLater', sort=10)

_testDoLater1 = None

_testDoLater2 = None

_monitorDoLater = None

# don't check until all the doLaters are finished

#tm._checkMemLeaks()

# doLater sort

l = []

def _testDoLaterPri1(task, l=l):

l.append(1)

def _testDoLaterPri2(task, l=l):

l.append(2)

def _monitorDoLaterPri(task, tm=tm, l=l, doLaterTests=doLaterTests):

if task.time > .02:

assert l == [1, 2,]

doLaterTests[0] -= 1

return task.done

return task.cont

tm.doMethodLater(.01, _testDoLaterPri1, 'testDoLaterPri1', sort=1)

tm.doMethodLater(.01, _testDoLaterPri2, 'testDoLaterPri2', sort=2)

doLaterTests[0] += 1

# make sure we run this task after the doLaters if they all occur on the same frame

tm.add(_monitorDoLaterPri, 'monitorDoLaterPri', sort=10)

_testDoLaterPri1 = None

_testDoLaterPri2 = None

_monitorDoLaterPri = None

# don't check until all the doLaters are finished

#tm._checkMemLeaks()

# doLater extraArgs

l = []

def _testDoLaterExtraArgs(arg1, l=l):

l.append(arg1)

def _monitorDoLaterExtraArgs(task, tm=tm, l=l, doLaterTests=doLaterTests):

if task.time > .02:

assert l == [3,]

doLaterTests[0] -= 1

return task.done

return task.cont

tm.doMethodLater(.01, _testDoLaterExtraArgs, 'testDoLaterExtraArgs', extraArgs=[3,])

doLaterTests[0] += 1

# make sure we run this task after the doLaters if they all occur on the same frame

tm.add(_monitorDoLaterExtraArgs, 'monitorDoLaterExtraArgs', sort=10)