Panda3D
|
Classes | |
class | AlphabetCounter |
class | Averager |
class | Default |
class | DelayedCall |
class | DelayedFunctor |
class | Enum |
class | EnumIter |
class | FrameDelayedCall |
class | Functor |
class | GoldenRectangle |
class | HierarchyException |
class | MiniLog |
class | MiniLogSentry |
class | PriorityCallbacks |
class | PStatScope |
class | Queue |
class | ScratchPad |
class | SerialMaskedGen |
class | SerialNumGen |
class | Singleton |
class | SingletonError |
class | Stack |
class | StackTrace |
class | StdoutCapture |
class | StdoutPassthrough |
class | SubframeCall |
class | Sync |
Functions | |
_clearProfileResultFileInfo (filename) | |
_getDtoolSuperBase () | |
_getProfileResultFileInfo (filename) | |
_getSafeReprNotify () | |
_installProfileCustomFuncs (filename) | |
_profileMarshalDump (data, file) | |
_profileMarshalLoad (file) | |
_profileOpen (filename, *args, **kArgs) | |
_profileWithoutGarbageLeak (cmd, filename) | |
_removeProfileCustomFuncs (filename) | |
_resolve_name (name, package, level) | |
_setProfileResultsFileInfo (filename, info) | |
addListsByValue (a, b) | |
adjust (command=None, dim=1, parent=None, **kw) | |
appendStr (obj, st) | |
average (*args) | |
boolEqual (a, b) | |
bound (value, bound1, bound2) | |
callerInfo (baseFileName=1, howFarBack=0) | |
clampScalar (value, a, b) | |
closestDestAngle (src, dest) | |
closestDestAngle2 (src, dest) | |
configIsToday (configName) | |
contains (whole, sub) | |
convertTree (objTree, idList) | |
deeptype (obj, maxLen=100, _visitedIds=None) | |
difference (a, b) | |
disjoint (L1, L2) | |
doc (obj) | |
endSuperLog () | |
exceptionLogged (append=True) | |
extractProfile (*args, **kArgs) | |
fastRepr (obj, maxLen=200, strFactor=10, _visitedIds=None) | |
findPythonModule (module) | |
fitDestAngle2Src (src, dest) | |
fitSrcAngle2Dest (src, dest) | |
flywheel (*args, **kArgs) | |
formatElapsedSeconds (seconds) | |
formatTimeCompact (seconds) | |
formatTimeExact (seconds) | |
getAnnounceGenerateTime (stat) | |
getNumberedTypedSortedString (items, maxLen=5000, numPrefix='') | |
getNumberedTypedString (items, maxLen=5000, numPrefix='') | |
getProfileResultString () | |
getSetter (targetObj, valueName, prefix='set') | |
getSetterName (valueName, prefix='set') | |
getShortestRotation (start, end) | |
getTotalAnnounceTime () | |
histogramDict (l) | |
import_module (name, package=None) | |
indent (stream, numIndents, str) | |
intersection (a, b) | |
invertDict (D, lossy=False) | |
invertDictLossless (D) | |
isDefaultValue (x) | |
itype (obj) | |
lerp (v0, v1, t) | |
lineInfo (baseFileName=1) | |
lineTag (baseFileName=1, verbose=0, separator=':') | |
lineupPos (i, num, spacing) | |
list2dict (L, value=None) | |
listToIndex2item (L) | |
listToItem2index (L) | |
logBlock (id, msg) | |
loopGen (l) | |
makeFlywheelGen (objects, countList=None, countFunc=None, scale=None) | |
makeList (x) | |
makeTuple (x) | |
mostDerivedLast (classList) | |
normalDistrib (a, b, gauss=random.gauss) | |
pretty_print (tree) | |
printListEnum (l) | |
printListEnumGen (l) | |
printNumberedTyped (items, maxLen=5000) | |
printNumberedTypes (items, maxLen=5000) | |
printNumberedTypesGen (items, maxLen=5000) | |
printProfile (filename=PyUtilProfileDefaultFilename, lines=PyUtilProfileDefaultLines, sorts=PyUtilProfileDefaultSorts, callInfo=1) | |
printThisCall () | |
profiled (category=None, terse=False) | |
profileFunc (callback, name, terse, log=True) | |
pstatcollect (scope, level=None) | |
quickProfile (name="unnamed") | |
r_convertTree (oldTree, newTree, idList) | |
r_pretty_print (tree, num) | |
randFloat (a, b=0., rng=random.random) | |
randInt32 (rng=random.random) | |
randUint31 (rng=random.random) | |
reduceAngle (deg) | |
replace (list, old, new, all=0) | |
report (types=[], prefix='', xform=None, notifyFunc=None, dConfigParam=[]) | |
safeRepr (obj) | |
safeReprTypeOnFail (obj) | |
safeTypeName (o) | |
sameElements (a, b) | |
serialNum () | |
solveQuadratic (a, b, c) | |
stackEntryInfo (depth=0, baseFileName=1) | |
startProfile (filename=PyUtilProfileDefaultFilename, lines=PyUtilProfileDefaultLines, sorts=PyUtilProfileDefaultSorts, silent=0, callInfo=1, useDisk=False, cmd='run()') | |
startSuperLog (customFunction=None) | |
testAlphabetCounter () | |
traceFunctionCall (frame) | |
traceParentCall () | |
typeName (o) | |
unescapeHtmlString (s) | |
union (a, b) | |
uniqueElements (L) | |
uniqueName (name) | |
weightedChoice (choiceList, rng=random.random, sum=None) | |
weightedRand (valDict, rng=random.random) | |
Contains miscellaneous utility functions and classes.
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
addListsByValue | ( | a, | |
b ) |
returns a new array containing the sums of the two array arguments (c[0] = a[0 + b[0], etc.)
adjust | ( | command = None, | |
dim = 1, | |||
parent = None, | |||
** | kw ) |
adjust(command = None, parent = None, **kw) Popup and entry scale to adjust a parameter Accepts any Slider keyword argument. Typical arguments include: command: The one argument command to execute min: The min value of the slider max: The max value of the slider resolution: The resolution of the slider text: The label on the slider These values can be accessed and/or changed after the fact >>> vg = adjust() >>> vg['min'] 0.0 >>> vg['min'] = 10.0 >>> vg['min'] 10.0
appendStr | ( | obj, | |
st ) |
adds a string onto the __str__ output of an instance
average | ( | * | args | ) |
returns simple average of list of values
boolEqual | ( | a, | |
b ) |
returns true if a and b are both true or both false. returns false otherwise (a.k.a. xnor -- eXclusive Not OR).
bound | ( | value, | |
bound1, | |||
bound2 ) |
returns value if value is between bound1 and bound2 otherwise returns bound that is closer to value
callerInfo | ( | baseFileName = 1, | |
howFarBack = 0 ) |
returns the sourcefilename, line number, and function name of the caller of the function that called this function (answers the question: 'hey callerInfo, who called me?') see stackEntryInfo, above, for info on 'baseFileName' and return types
clampScalar | ( | value, | |
a, | |||
b ) |
closestDestAngle | ( | src, | |
dest ) |
closestDestAngle2 | ( | src, | |
dest ) |
configIsToday | ( | configName | ) |
contains | ( | whole, | |
sub ) |
Return 1 if whole contains sub, 0 otherwise
convertTree | ( | objTree, | |
idList ) |
deeptype | ( | obj, | |
maxLen = 100, | |||
_visitedIds = None ) |
difference | ( | a, | |
b ) |
difference(list, list):
disjoint | ( | L1, | |
L2 ) |
returns non-zero if L1 and L2 have no common elements
doc | ( | obj | ) |
endSuperLog | ( | ) |
exceptionLogged | ( | append = True | ) |
decorator that outputs the function name and all arguments if an exception passes back through the stack frame if append is true, string is appended to the __str__ output of the exception. if append is false, string is printed to the log directly. If the output will take up many lines, it's recommended to set append to False so that the exception stack is not hidden by the output of this decorator.
extractProfile | ( | * | args, |
** | kArgs ) |
fastRepr | ( | obj, | |
maxLen = 200, | |||
strFactor = 10, | |||
_visitedIds = None ) |
caps the length of iterable types, so very large objects will print faster. also prevents infinite recursion
findPythonModule | ( | module | ) |
fitDestAngle2Src | ( | src, | |
dest ) |
given a src and destination angle, returns an equivalent dest angle that is within [-180..180) of src examples: fitDestAngle2Src(30, 60) == 60 fitDestAngle2Src(60, 30) == 30 fitDestAngle2Src(0, 180) == -180 fitDestAngle2Src(1, 180) == 180
fitSrcAngle2Dest | ( | src, | |
dest ) |
given a src and destination angle, returns an equivalent src angle that is within [-180..180) of dest examples: fitSrcAngle2Dest(30, 60) == 30 fitSrcAngle2Dest(60, 30) == 60 fitSrcAngle2Dest(0, 180) == 0 fitSrcAngle2Dest(-1, 180) == 359 fitSrcAngle2Dest(-180, 180) == 180
flywheel | ( | * | args, |
** | kArgs ) |
>>> for i in flywheel([1,2,3], countList=[10, 5, 1]): ... print i, ... 1 2 3 1 2 1 2 1 2 1 2 1 1 1 1 1
formatElapsedSeconds | ( | seconds | ) |
Returns a string of the form "mm:ss" or "hh:mm:ss" or "n days", representing the indicated elapsed time in seconds.
formatTimeCompact | ( | seconds | ) |
formatTimeExact | ( | seconds | ) |
getAnnounceGenerateTime | ( | stat | ) |
getNumberedTypedSortedString | ( | items, | |
maxLen = 5000, | |||
numPrefix = '' ) |
get a string that has each item of the list on its own line, the items are stringwise-sorted, and each item is numbered on the left from zero
getNumberedTypedString | ( | items, | |
maxLen = 5000, | |||
numPrefix = '' ) |
get a string that has each item of the list on its own line, and each item is numbered on the left from zero
getProfileResultString | ( | ) |
getSetter | ( | targetObj, | |
valueName, | |||
prefix = 'set' ) |
getSetterName | ( | valueName, | |
prefix = 'set' ) |
getShortestRotation | ( | start, | |
end ) |
Given two heading values, return a tuple describing the shortest interval from 'start' to 'end'. This tuple can be used to lerp a camera between two rotations while avoiding the 'spin' problem.
getTotalAnnounceTime | ( | ) |
histogramDict | ( | l | ) |
import_module | ( | name, | |
package = None ) |
indent | ( | stream, | |
numIndents, | |||
str ) |
Write str to stream with numIndents in front of it
intersection | ( | a, | |
b ) |
intersection(list, list):
invertDict | ( | D, | |
lossy = False ) |
creates a dictionary by 'inverting' D; keys are placed in the new dictionary under their corresponding value in the old dictionary. It is an error if D contains any duplicate values. >>> old = {'key1':1, 'key2':2} >>> invertDict(old) {1: 'key1', 2: 'key2'}
invertDictLossless | ( | D | ) |
similar to invertDict, but values of new dict are lists of keys from old dict. No information is lost. >>> old = {'key1':1, 'key2':2, 'keyA':2} >>> invertDictLossless(old) {1: ['key1'], 2: ['key2', 'keyA']}
isDefaultValue | ( | x | ) |
itype | ( | obj | ) |
lerp | ( | v0, | |
v1, | |||
t ) |
returns a value lerped between v0 and v1, according to t t == 0 maps to v0, t == 1 maps to v1
lineInfo | ( | baseFileName = 1 | ) |
returns the sourcefilename, line number, and function name of the code that called this function (answers the question: 'hey lineInfo, where am I in the codebase?') see stackEntryInfo, above, for info on 'baseFileName' and return types
lineTag | ( | baseFileName = 1, | |
verbose = 0, | |||
separator = ':' ) |
returns a string containing the sourcefilename and line number of the code that called this function (equivalent to lineInfo, above, with different return type) see stackEntryInfo, above, for info on 'baseFileName' if 'verbose' is false, returns a compact string of the form 'fileName:lineNum:funcName' if 'verbose' is true, returns a longer string that matches the format of Python stack trace dumps returns empty string on error
lineupPos | ( | i, | |
num, | |||
spacing ) |
use to line up a series of 'num' objects, in one dimension, centered around zero 'i' is the index of the object in the lineup 'spacing' is the amount of space between objects in the lineup
list2dict | ( | L, | |
value = None ) |
creates dict using elements of list, all assigned to same value
listToIndex2item | ( | L | ) |
converts list to dict of list index->list item
listToItem2index | ( | L | ) |
converts list to dict of list item->list index This is lossy if there are duplicate list items
logBlock | ( | id, | |
msg ) |
loopGen | ( | l | ) |
makeFlywheelGen | ( | objects, | |
countList = None, | |||
countFunc = None, | |||
scale = None ) |
makeList | ( | x | ) |
returns x, converted to a list
makeTuple | ( | x | ) |
returns x, converted to a tuple
mostDerivedLast | ( | classList | ) |
pass in list of classes. sorts list in-place, with derived classes appearing after their bases
normalDistrib | ( | a, | |
b, | |||
gauss = random.gauss ) |
NOTE: assumes a < b Returns random number between a and b, using gaussian distribution, with mean=avg(a, b), and a standard deviation that fits ~99.7% of the curve between a and b. For ease of use, outlying results are re-computed until result is in [a, b] This should fit the remaining .3% of the curve that lies outside [a, b] uniformly onto the curve inside [a, b] ------------------------------------------------------------------------ The 68-95-99.7% Rule ==================== All normal density curves satisfy the following property which is often referred to as the Empirical Rule: 68% of the observations fall within 1 standard deviation of the mean. 95% of the observations fall within 2 standard deviations of the mean. 99.7% of the observations fall within 3 standard deviations of the mean. Thus, for a normal distribution, almost all values lie within 3 standard deviations of the mean. ------------------------------------------------------------------------ In calculating our standard deviation, we divide (b-a) by 6, since the 99.7% figure includes 3 standard deviations _on_either_side_ of the mean.
pretty_print | ( | tree | ) |
printListEnum | ( | l | ) |
printListEnumGen | ( | l | ) |
printNumberedTyped | ( | items, | |
maxLen = 5000 ) |
print out each item of the list on its own line, with each item numbered on the left from zero
printNumberedTypes | ( | items, | |
maxLen = 5000 ) |
print out the type of each item of the list on its own line, with each item numbered on the left from zero
printNumberedTypesGen | ( | items, | |
maxLen = 5000 ) |
printProfile | ( | filename = PyUtilProfileDefaultFilename, | |
lines = PyUtilProfileDefaultLines, | |||
sorts = PyUtilProfileDefaultSorts, | |||
callInfo = 1 ) |
printThisCall | ( | ) |
profiled | ( | category = None, | |
terse = False ) |
decorator for profiling functions turn categories on and off via "want-profile-categoryName 1" e.g.:: @profiled('particles') def loadParticles(): ... :: want-profile-particles 1
profileFunc | ( | callback, | |
name, | |||
terse, | |||
log = True ) |
pstatcollect | ( | scope, | |
level = None ) |
quickProfile | ( | name = "unnamed" | ) |
r_convertTree | ( | oldTree, | |
newTree, | |||
idList ) |
r_pretty_print | ( | tree, | |
num ) |
randFloat | ( | a, | |
b = 0., | |||
rng = random.random ) |
returns a random float in [a, b] call with single argument to generate random float between arg and zero
randInt32 | ( | rng = random.random | ) |
returns a random integer in [-2147483648..2147483647]. rng must return float in [0..1]
randUint31 | ( | rng = random.random | ) |
returns a random integer in [0..2^31). rng must return float in [0..1]
reduceAngle | ( | deg | ) |
Reduces an angle (in degrees) to a value in [-180..180)
replace | ( | list, | |
old, | |||
new, | |||
all = 0 ) |
replace 'old' with 'new' in 'list' if all == 0, replace first occurrence otherwise replace all occurrences returns the number of items replaced
report | ( | types = [], | |
prefix = '', | |||
xform = None, | |||
notifyFunc = None, | |||
dConfigParam = [] ) |
This is a decorator generating function. Use is similar to a @decorator, except you must be sure to call it as a function. It actually returns the decorator which is then used to transform your decorated function. Confusing at first, I know. Decoration occurs at function definition time. If __dev__ is not defined, or resolves to False, this function has no effect and no wrapping/transform occurs. So in production, it's as if the report has been asserted out. Parameters: types: A subset list of ['timeStamp', 'frameCount', 'avLocation'] This allows you to specify certain useful bits of info: - *module*: Prints the module that this report statement can be found in. - *args*: Prints the arguments as they were passed to this function. - *timeStamp*: Adds the current frame time to the output. - *deltaStamp*: Adds the current AI synched frame time to the output - *frameCount*: Adds the current frame count to the output. Usually cleaner than the timeStamp output. - *avLocation*: Adds the localAvatar's network location to the output. Useful for interest debugging. - *interests*: Prints the current interest state after the report. - *stackTrace*: Prints a stack trace after the report. prefix: Optional string to prepend to output, just before the function. Allows for easy grepping and is useful when merging AI/Client reports into a single file. xform: Optional callback that accepts a single parameter: argument 0 to the decorated function. (assumed to be 'self') It should return a value to be inserted into the report output string. notifyFunc: A notify function such as info, debug, warning, etc. By default the report will be printed to stdout. This will allow you send the report to a designated 'notify' output. dConfigParam: A list of Config.prc string variables. By default the report will always print. If you specify this param, it will only print if one of the specified config strings resolve to True.
safeRepr | ( | obj | ) |
safeReprTypeOnFail | ( | obj | ) |
safeTypeName | ( | o | ) |
sameElements | ( | a, | |
b ) |
serialNum | ( | ) |
solveQuadratic | ( | a, | |
b, | |||
c ) |
stackEntryInfo | ( | depth = 0, | |
baseFileName = 1 ) |
returns the sourcefilename, line number, and function name of an entry in the stack. 'depth' is how far back to go in the stack; 0 is the caller of this function, 1 is the function that called the caller of this function, etc. by default, strips off the path of the filename; override with baseFileName returns (fileName, lineNum, funcName) --> (string, int, string) returns (None, None, None) on error
startProfile | ( | filename = PyUtilProfileDefaultFilename, | |
lines = PyUtilProfileDefaultLines, | |||
sorts = PyUtilProfileDefaultSorts, | |||
silent = 0, | |||
callInfo = 1, | |||
useDisk = False, | |||
cmd = 'run()' ) |
startSuperLog | ( | customFunction = None | ) |
testAlphabetCounter | ( | ) |
traceFunctionCall | ( | frame | ) |
return a string that shows the call frame with calling arguments. e.g. foo(x=234, y=135)
traceParentCall | ( | ) |
typeName | ( | o | ) |
unescapeHtmlString | ( | s | ) |
union | ( | a, | |
b ) |
union(list, list):
uniqueElements | ( | L | ) |
are all elements of list unique?
uniqueName | ( | name | ) |
weightedChoice | ( | choiceList, | |
rng = random.random, | |||
sum = None ) |
given a list of (weight, item) pairs, chooses an item based on the weights. rng must return 0..1. if you happen to have the sum of the weights, pass it in 'sum'.
weightedRand | ( | valDict, | |
rng = random.random ) |
pass in a dictionary with a selection -> weight mapping. E.g.:: {"Choice 1": 10, "Choice 2": 30, "bear": 100} - Weights need not add up to any particular value. - The actual selection will be returned.
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
appendStr |
bound |
clamp = bound |
classobj |
configIsToday |
deeptype |
Default |
DelayedCall |
DelayedFunctor |
dtoolSuperBase = None |
exceptionLogged |
exceptionLoggedNotify = None |
fastRepr |
flywheel |
FrameDelayedCall |
ftc = formatTimeCompact |
fte = formatTimeExact |
getBase |
getRepository |
tuple GoldenRatio = (1. + math.sqrt(5.)) / 2. |
HierarchyException |
histogramDict |
imp = import_module('imp') |
import_module |
importlib = imp.new_module("importlib") |
invertDict |
invertDictLossless |
itype |
lerp |
logBlock |
loopGen |
makeList |
makeTuple |
MiniLog |
MiniLogSentry |
list movedDumpFuncs = [] |
list movedLoadFuncs = [] |
list movedOpenFuncs = [] |
nullGen |
printReverseStack |
printStack |
printVerboseStack |
profiled |
dict profileFilename2file = {} |
dict profileFilename2marshalData = {} |
profileFilenameList = Stack() |
profileFilenames = set() |
pstatcollect |
str PyUtilProfileDefaultFilename = 'profiledata' |
int PyUtilProfileDefaultLines = 80 |
list PyUtilProfileDefaultSorts = ['cumulative', 'time', 'calls'] |
rad180 = math.pi |
float rad270 = 1.5 * math.pi |
int rad360 = 2. * math.pi |
int rad90 = math.pi / 2. |
report |
safeRepr |
safeReprNotify = None |
safeTypeName |
StackTrace |
SubframeCall |
superLogFile = None |
typeName |
xrange = range |