'indent', 'doc', 'adjust', 'difference', 'intersection', 'union',

'sameElements', 'makeList', 'makeTuple', 'list2dict', 'invertDict',

'invertDictLossless', 'uniqueElements', 'disjoint', 'contains', 'replace',

'reduceAngle', 'fitSrcAngle2Dest', 'fitDestAngle2Src', 'closestDestAngle2',

'closestDestAngle', 'getSetterName', 'getSetter', 'Functor', 'Stack',

'Queue', 'bound', 'clamp', 'lerp', 'average', 'addListsByValue',

'boolEqual', 'lineupPos', 'formatElapsedSeconds', 'solveQuadratic',

'findPythonModule', 'mostDerivedLast', 'clampScalar', 'weightedChoice',

'randFloat', 'normalDistrib', 'weightedRand', 'randUint31', 'randInt32',

'SerialNumGen', 'serialNum', 'uniqueName', 'Enum', 'Singleton',

'SingletonError', 'printListEnum', 'safeRepr', 'fastRepr',

'isDefaultValue', 'ScratchPad', 'Sync', 'itype', 'getNumberedTypedString',

'getNumberedTypedSortedString', 'printNumberedTyped', 'DelayedCall',

'DelayedFunctor', 'FrameDelayedCall', 'SubframeCall', 'getBase',

'GoldenRatio', 'GoldenRectangle', 'rad90', 'rad180', 'rad270', 'rad360',

'nullGen', 'loopGen', 'makeFlywheelGen', 'flywheel', 'listToIndex2item',

'listToItem2index', 'formatTimeCompact', 'deeptype', 'StdoutCapture',

'StdoutPassthrough', 'Averager', 'getRepository', 'formatTimeExact',

'startSuperLog', 'endSuperLog', 'typeName', 'safeTypeName',

'histogramDict', 'unescapeHtmlString',

def __init__(self, function, *args, **kargs):

assert callable(function), "function should be a callable obj"

self._function = function

self._args = args

self._kargs = kargs

if hasattr(self._function, '__name__'):

self.__name__ = self._function.__name__

else:

self.__name__ = str(itype(self._function))

if hasattr(self._function, '__doc__'):

self.__doc__ = self._function.__doc__

else:

self.__doc__ = self.__name__

def destroy(self):

del self._function

del self._args

del self._kargs

del self.__name__

del self.__doc__

def _do__call__(self, *args, **kargs):

_kargs = self._kargs.copy()

_kargs.update(kargs)

return self._function(*(self._args + args), **_kargs)

__call__ = _do__call__

def __repr__(self):

s = 'Functor(%s' % self._function.__name__

for arg in self._args:

try:

argStr = repr(arg)

except:

argStr = 'bad repr: %s' % arg.__class__

s += ', %s' % argStr

for karg, value in list(self._kargs.items()):

s += ', %s=%s' % (karg, repr(value))

s += ')'

def __init__(self):

self.__list = []

def push(self, item):

self.__list.append(item)

def top(self):

# return the item on the top of the stack without popping it off

return self.__list[-1]

def pop(self):

return self.__list.pop()

def clear(self):

self.__list = []

def isEmpty(self):

return len(self.__list) == 0

def __len__(self):

# FIFO queue

# interface is intentionally identical to Stack (LIFO)

def __init__(self):

self.__list = []

def push(self, item):

self.__list.append(item)

def top(self):

# return the next item at the front of the queue without popping it off

return self.__list[0]

def front(self):

return self.__list[0]

def back(self):

return self.__list[-1]

def pop(self):

return self.__list.pop(0)

def clear(self):

self.__list = []

def isEmpty(self):

return len(self.__list) == 0

def __len__(self):

"""

# To match emacs, instead of a tab character we will use 4 spaces

def __init__(self, label="", start=0, limit=None):

"""

self.label = label

if limit is not None:

self.trace = traceback.extract_stack(sys._getframe(1+start),

limit=limit)

else:

self.trace = traceback.extract_stack(sys._getframe(1+start))

def compact(self):

r = ''

comma = ','

for filename, lineNum, funcName, text in self.trace:

r += '%s.%s:%s%s' % (filename[:filename.rfind('.py')][filename.rfind('\\')+1:], funcName, lineNum, comma)

if len(r):

r = r[:-len(comma)]

return r

def reverseCompact(self):

r = ''

comma = ','

for filename, lineNum, funcName, text in self.trace:

r = '%s.%s:%s%s%s' % (filename[:filename.rfind('.py')][filename.rfind('\\')+1:], funcName, lineNum, comma, r)

if len(r):

r = r[:-len(comma)]

return r

def __str__(self):

r = "Debug stack trace of %s (back %s frames):\n"%(

self.label, len(self.trace),)

for i in traceback.format_list(self.trace):

r+=i

r+="***** NOTE: This is not a crash. This is a debug stack trace. *****"

"""

f = frame

co = f.f_code

dict = f.f_locals

n = co.co_argcount

if co.co_flags & 4: n = n+1

if co.co_flags & 8: n = n+1

r=''

if 'self' in dict:

r = '%s.'%(dict['self'].__class__.__name__,)

r+="%s("%(f.f_code.co_name,)

comma=0 # formatting, whether we should type a comma.

for i in range(n):

name = co.co_varnames[i]

if name=='self':

continue

if comma:

r+=', '

else:

# ok, we skipped the first one, the rest get commas:

comma=1

r+=name

r+='='

if name in dict:

v=safeRepr(dict[name])

if len(v)>2000:

# r+="<too big for debug>"

r += (v[:2000] + "...")

else:

r+=v

else: r+="*** undefined ***"

"""

# Make sure we enable Tk

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

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

Valuator = importlib.import_module('direct.tkwidgets.Valuator')

# Set command if specified

if command:

kw['command'] = lambda x: command(*x)

if parent is None:

kw['title'] = command.__name__

kw['dim'] = dim

# Create toplevel if needed

if not parent:

vg = Valuator.ValuatorGroupPanel(parent, **kw)

else:

vg = Valuator.ValuatorGroup(parent, **kw)

vg.pack(expand = 1, fill = 'x')

"""

if not a: return b

if not b: return a

d = []

for i in a:

if (i not in b) and (i not in d):

d.append(i)

for i in b:

if (i not in a) and (i not in d):

d.append(i)

"""

if not a: return []

if not b: return []

d = []

for i in a:

if (i in b) and (i not in d):

d.append(i)

for i in b:

if (i in a) and (i not in d):

d.append(i)

"""

# Copy a

c = a[:]

for i in b:

if (i not in c):

c.append(i)

if len(a) != len(b):

return 0

for elem in a:

if elem not in b:

return 0

for elem in b:

if elem not in a:

return 0

"""returns x, converted to a list"""

if type(x) is list:

return x

elif type(x) is tuple:

return list(x)

else:

"""returns x, converted to a tuple"""

if type(x) is list:

return tuple(x)

elif type(x) is tuple:

return x

else:

"""converts list to dict of list index->list item"""

d = {}

for i, item in enumerate(L):

d[i] = item

"""converts list to dict of list item->list index

d = {}

for i, item in enumerate(L):

d[item] = i

"""creates a dictionary by 'inverting' D; keys are placed in the new

n = {}

for key, value in D.items():

if not lossy and value in n:

raise Exception('duplicate key in invertDict: %s' % value)

n[value] = key

"""similar to invertDict, but values of new dict are lists of keys from

n = {}

for key, value in D.items():

n.setdefault(value, [])

n[value].append(key)

"""returns non-zero if L1 and L2 have no common elements"""

used = dict([(k, None) for k in L1])

for k in L2:

if k in used:

return 0

"""

if (whole == sub):

return 1

for elem in sub:

# The first item you find not in whole, return 0

if elem not in whole:

return 0

# If you got here, whole must contain sub

"""

if old not in list:

return 0

if not all:

i = list.index(old)

list[i] = new

return 1

else:

numReplaced = 0

for i in range(len(list)):

if list[i] == old:

numReplaced += 1

list[i] = new

"""

"""

"""

# The function above didn't seem to do what I wanted. So I hacked

# this one together. I can't really say I understand it. It's more

# from impirical observation... GRW

diff = src - dest

if diff > 180:

# if the difference is greater that 180 it's shorter to go the other way

return dest - 360

elif diff < -180:

# or perhaps the OTHER other way...

return dest + 360

else:

# otherwise just go to the original destination

# The function above didn't seem to do what I wanted. So I hacked

# this one together. I can't really say I understand it. It's more

# from impirical observation... GRW

diff = src - dest

if diff > 180:

# if the difference is greater that 180 it's shorter to go the other way

return src - (diff - 360)

elif diff < -180:

# or perhaps the OTHER other way...

return src - (360 + diff)

else:

# otherwise just go to the original destination

# redirects stdout to a string

def __init__(self):

self._oldStdout = sys.stdout

sys.stdout = self

self._string = ''

def destroy(self):

sys.stdout = self._oldStdout

del self._oldStdout

def getString(self):

return self._string

# internal

def write(self, string):

# like StdoutCapture but also allows output to go through to the OS as normal

# internal

def write(self, string):

self._string = ''.join([self._string, string])

# if you called profile with 'log' not set to True,

# you can call this function to get the results as

# a string

global _ProfileResultStr

global _ProfileResultStr

if 'globalProfileFunc' in builtins.__dict__:

# rats. Python profiler is not re-entrant...

base.notify.warning(

'PythonUtil.profileStart(%s): aborted, already profiling %s'

#'\nStack Trace:\n%s'

% (name, builtins.globalProfileFunc,

#StackTrace()

))

return

builtins.globalProfileFunc = callback

builtins.globalProfileResult = [None]

prefix = '***** START PROFILE: %s *****' % name

if log:

print(prefix)

startProfile(cmd='globalProfileResult[0]=globalProfileFunc()', callInfo=(not terse), silent=not log)

suffix = '***** END PROFILE: %s *****' % name

if log:

print(suffix)

else:

_ProfileResultStr = '%s\n%s\n%s' % (prefix, _ProfileResultStr, suffix)

result = globalProfileResult[0]

del builtins.__dict__['globalProfileFunc']

del builtins.__dict__['globalProfileResult']

""" decorator for profiling functions

assert type(category) in (str, type(None)), "must provide a category name for @profiled"

# allow profiling in published versions

"""

def profileDecorator(f):

def _profiled(*args, **kArgs):

name = '(%s) %s from %s' % (category, f.__name__, f.__module__)

# showbase might not be loaded yet, so don't use

# base.config. Instead, query the ConfigVariableBool.

if (category is None) or ConfigVariableBool('want-profile-%s' % category, 0).getValue():

return profileFunc(Functor(f, *args, **kArgs), name, terse)

else:

return f(*args, **kArgs)

_profiled.__doc__ = f.__doc__

return _profiled

# this is a replacement for the file open() builtin function

# for use during profiling, to intercept the file open

# operation used by the Python profiler and profile stats

# systems

if filename in profileFilenames:

# if this is a file related to profiling, create an

# in-RAM file object

if filename not in profileFilename2file:

file = StringIO()

file._profFilename = filename

profileFilename2file[filename] = file

else:

file = profileFilename2file[filename]

else:

file = movedOpenFuncs[-1](filename, *args, **kArgs)

# marshal.dump doesn't work with StringIO objects

# simulate it

if isinstance(file, StringIO) and hasattr(file, '_profFilename'):

if file._profFilename in profileFilenames:

profileFilename2marshalData[file._profFilename] = data

return None

# marshal.load doesn't work with StringIO objects

# simulate it

if isinstance(file, StringIO) and hasattr(file, '_profFilename'):

if file._profFilename in profileFilenames:

return profileFilename2marshalData[file._profFilename]

assert filename not in profileFilenames

profileFilenames.add(filename)

profileFilenameList.push(filename)

movedOpenFuncs.append(builtins.open)

builtins.open = _profileOpen

movedDumpFuncs.append(marshal.dump)

marshal.dump = _profileMarshalDump

movedLoadFuncs.append(marshal.load)

f, m = info

if f:

profileFilename2file[filename] = f

if m:

assert profileFilenameList.top() == filename

marshal.load = movedLoadFuncs.pop()

marshal.dump = movedDumpFuncs.pop()

builtins.open = movedOpenFuncs.pop()

profileFilenames.remove(filename)

profileFilenameList.pop()

profileFilename2file.pop(filename, None)

# don't let marshalled data pile up

# The profile module isn't necessarily installed on every Python

# installation, so we import it here, instead of in the module

# scope.

import profile

# this is necessary because the profile module creates a memory leak

Profile = profile.Profile

statement = cmd

sort = -1

retVal = None

#### COPIED FROM profile.run ####

prof = Profile()

try:

prof = prof.run(statement)

except SystemExit:

pass

if filename is not None:

prof.dump_stats(filename)

else:

#return prof.print_stats(sort) #DCR

retVal = prof.print_stats(sort) #DCR

#################################

# eliminate the garbage leak

del prof.dispatcher

lines=PyUtilProfileDefaultLines,

sorts=PyUtilProfileDefaultSorts,

silent=0,

callInfo=1,

useDisk=False,

cmd='run()'):

# uniquify the filename to allow multiple processes to profile simultaneously

filename = '%s.%s%s' % (filename, randUint31(), randUint31())

if not useDisk:

# use a RAM file

_installProfileCustomFuncs(filename)

_profileWithoutGarbageLeak(cmd, filename)

if silent:

extractProfile(filename, lines, sorts, callInfo)

else:

printProfile(filename, lines, sorts, callInfo)

if not useDisk:

# discard the RAM file

_removeProfileCustomFuncs(filename)

else:

lines=PyUtilProfileDefaultLines,

sorts=PyUtilProfileDefaultSorts,

callInfo=1):

import pstats

s = pstats.Stats(filename)

s.strip_dirs()

for sort in sorts:

s.sort_stats(sort)

s.print_stats(lines)

if callInfo:

s.print_callees(lines)

global _ProfileResultStr

# capture print output

sc = StdoutCapture()

# print the profile output, redirected to the result string

printProfile(*args, **kArgs)

# make a copy of the print output

_ProfileResultStr = sc.getString()

# restore stdout to what it was before

"""pass in list of classes. sorts list in-place, with derived classes

class ClassSortKey(object):

__slots__ = 'classobj',

def __init__(self, classobj):

self.classobj = classobj

def __lt__(self, other):

return issubclass(other.classobj, self.classobj)

"""

if bound1 > bound2:

return min(max(value, bound2), bound1)

else:

"""

"""

start, end = start % 360, end % 360

if abs(end - start) > 180:

if end < start:

end += 360

else:

start += 360

""" returns simple average of list of values """

val = 0.

for arg in args:

val += arg

def __init__(self, name):

self._name = name

self.reset()

def reset(self):

self._total = 0.

self._count = 0

def addValue(self, value):

self._total += value

self._count += 1

def getAverage(self):

return self._total / self._count

def getCount(self):

"""

c = []

for x, y in zip(a, b):

c.append(x + y)

"""

"""

assert num >= 1

assert i >= 0 and i < num

pos = float(i) * spacing

"""

sign = ''

if seconds < 0:

seconds = -seconds

sign = '-'

# We use math.floor() instead of casting to an int, so we avoid

# problems with numbers that are too large to represent as

# type int.

seconds = math.floor(seconds)

hours = math.floor(seconds / (60 * 60))

if hours > 36:

days = math.floor((hours + 12) / 24)

return "%s%d days" % (sign, days)

seconds -= hours * (60 * 60)

minutes = (int)(seconds / 60)

seconds -= minutes * 60

if hours != 0:

return "%s%d:%02d:%02d" % (sign, hours, minutes, seconds)

else:

# quadratic equation: ax^2 + bx + c = 0

# quadratic formula: x = [-b +/- sqrt(b^2 - 4ac)] / 2a

# returns None, root, or [root1, root2]

# a cannot be zero.

if a == 0.:

return None

# calculate the determinant (b^2 - 4ac)

D = (b * b) - (4. * a * c)

if D < 0:

# there are no solutions (sqrt(negative number) is undefined)

return None

elif D == 0:

# only one root

return (-b) / (2. * a)

else:

# OK, there are two roots

sqrtD = math.sqrt(D)

twoA = 2. * a

root1 = ((-b) - sqrtD) / twoA

root2 = ((-b) + sqrtD) / twoA

"""

import inspect

try: