Panda3D

Loading...
Searching...
No Matches
Classes | Functions | Variables
direct.showbase.PythonUtil Namespace Reference

## 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)

## Variables
int | _KEY_DICT = 8
int | _POS_LIST = 4
str | _ProfileResultStr = ''
| _resolve_name
| _serialGen = SerialNumGen()
| appendStr
| bound
| clamp = bound
| classobj = 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

## Detailed Description

    Contains miscellaneous utility functions and classes.

## Function Documentation

## ◆ _clearProfileResultFileInfo()

_clearProfileResultFileInfo | ( |  | filename | ) |
| protected

## ◆ _getDtoolSuperBase()

_getDtoolSuperBase | ( |  | ) |
| protected

## ◆ _getProfileResultFileInfo()

_getProfileResultFileInfo | ( |  | filename | ) |
| protected

## ◆ _getSafeReprNotify()

_getSafeReprNotify | ( |  | ) |
| protected

## ◆ _installProfileCustomFuncs()

_installProfileCustomFuncs | ( |  | filename | ) |
| protected

## ◆ _profileMarshalDump()

_profileMarshalDump | ( |  | data,
|  |  | file )
| protected

## ◆ _profileMarshalLoad()

_profileMarshalLoad | ( |  | file | ) |
| protected

## ◆ _profileOpen()

_profileOpen | ( |  | filename,
|  | * | args,
|  | ** | kArgs )
| protected

## ◆ _profileWithoutGarbageLeak()

_profileWithoutGarbageLeak | ( |  | cmd,
|  |  | filename )
| protected

## ◆ _removeProfileCustomFuncs()

_removeProfileCustomFuncs | ( |  | filename | ) |
| protected

## ◆ _resolve_name()

_resolve_name | ( |  | name,
|  |  | package,
|  |  | level )
| protected

## ◆ _setProfileResultsFileInfo()

_setProfileResultsFileInfo | ( |  | filename,
|  |  | info )
| protected

## ◆ addListsByValue()

addListsByValue | ( |  | a,
|  |  | b )

    returns a new array containing the sums of the two array arguments
    (c[0] = a[0 + b[0], etc.)

## ◆ adjust()

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()

appendStr | ( |  | obj,
|  |  | st )

    adds a string onto the __str__ output of an instance

## ◆ average()

average | ( | * | args | ) |

     returns simple average of list of values

## ◆ boolEqual()

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()

bound | ( |  | value,
|  |  | bound1,
|  |  | bound2 )

    returns value if value is between bound1 and bound2
    otherwise returns bound that is closer to value

## ◆ callerInfo()

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()

clampScalar | ( |  | value,
|  |  | a,
|  |  | b )

## ◆ closestDestAngle()

closestDestAngle | ( |  | src,
|  |  | dest )

## ◆ closestDestAngle2()

closestDestAngle2 | ( |  | src,
|  |  | dest )

## ◆ configIsToday()

configIsToday | ( |  | configName | ) |

## ◆ contains()

contains | ( |  | whole,
|  |  | sub )

    Return 1 if whole contains sub, 0 otherwise

## ◆ convertTree()

convertTree | ( |  | objTree,
|  |  | idList )

## ◆ deeptype()

deeptype | ( |  | obj,
|  |  | maxLen = 100,
|  |  | _visitedIds = None )

## ◆ difference()

difference | ( |  | a,
|  |  | b )

    difference(list, list):

## ◆ disjoint()

disjoint | ( |  | L1,
|  |  | L2 )

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

## ◆ doc()

doc | ( |  | obj | ) |

## ◆ endSuperLog()

endSuperLog | ( |  | ) |

## ◆ exceptionLogged()

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()

extractProfile | ( | * | args,
|  | ** | kArgs )

## ◆ fastRepr()

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()

findPythonModule | ( |  | module | ) |

## ◆ fitDestAngle2Src()

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()

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()

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()

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()

formatTimeCompact | ( |  | seconds | ) |

## ◆ formatTimeExact()

formatTimeExact | ( |  | seconds | ) |

## ◆ getAnnounceGenerateTime()

getAnnounceGenerateTime | ( |  | stat | ) |

## ◆ getNumberedTypedSortedString()

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()

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()

getProfileResultString | ( |  | ) |

## ◆ getSetter()

getSetter | ( |  | targetObj,
|  |  | valueName,
|  |  | prefix = 'set' )

## ◆ getSetterName()

getSetterName | ( |  | valueName,
|  |  | prefix = 'set' )

## ◆ getShortestRotation()

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()

getTotalAnnounceTime | ( |  | ) |

## ◆ histogramDict()

histogramDict | ( |  | l | ) |

## ◆ import_module()

import_module | ( |  | name,
|  |  | package = None )

## ◆ indent()

indent | ( |  | stream,
|  |  | numIndents,
|  |  | str )

    Write str to stream with numIndents in front of it

## ◆ intersection()

intersection | ( |  | a,
|  |  | b )

    intersection(list, list):

## ◆ invertDict()

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()

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()

isDefaultValue | ( |  | x | ) |

## ◆ itype()

itype | ( |  | obj | ) |

## ◆ lerp()

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()

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()

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()

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()

list2dict | ( |  | L,
|  |  | value = None )

    creates dict using elements of list, all assigned to same value

## ◆ listToIndex2item()

listToIndex2item | ( |  | L | ) |

    converts list to dict of list index->list item

## ◆ listToItem2index()

listToItem2index | ( |  | L | ) |

    converts list to dict of list item->list index
    This is lossy if there are duplicate list items

## ◆ logBlock()

logBlock | ( |  | id,
|  |  | msg )

## ◆ loopGen()

loopGen | ( |  | l | ) |

## ◆ makeFlywheelGen()

makeFlywheelGen | ( |  | objects,
|  |  | countList = None,
|  |  | countFunc = None,
|  |  | scale = None )

## ◆ makeList()

makeList | ( |  | x | ) |

    returns x, converted to a list

## ◆ makeTuple()

makeTuple | ( |  | x | ) |

    returns x, converted to a tuple

## ◆ mostDerivedLast()

mostDerivedLast | ( |  | classList | ) |

    pass in list of classes. sorts list in-place, with derived classes
    appearing after their bases

## ◆ normalDistrib()

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()

pretty_print | ( |  | tree | ) |

## ◆ printListEnum()

printListEnum | ( |  | l | ) |

## ◆ printListEnumGen()

printListEnumGen | ( |  | l | ) |

## ◆ printNumberedTyped()

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()

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()

printNumberedTypesGen | ( |  | items,
|  |  | maxLen = 5000 )

## ◆ printProfile()

printProfile | ( |  | filename = PyUtilProfileDefaultFilename,
|  |  | lines = PyUtilProfileDefaultLines,
|  |  | sorts = PyUtilProfileDefaultSorts,
|  |  | callInfo = 1 )

## ◆ printThisCall()

printThisCall | ( |  | ) |

## ◆ profiled()

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()

profileFunc | ( |  | callback,
|  |  | name,
|  |  | terse,
|  |  | log = True )

## ◆ pstatcollect()

pstatcollect | ( |  | scope,
|  |  | level = None )

## ◆ quickProfile()

quickProfile | ( |  | name = "unnamed" | ) |

## ◆ r_convertTree()

r_convertTree | ( |  | oldTree,
|  |  | newTree,
|  |  | idList )

## ◆ r_pretty_print()

r_pretty_print | ( |  | tree,
|  |  | num )

## ◆ randFloat()

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()

randInt32 | ( |  | rng = random.random | ) |

    returns a random integer in [-2147483648..2147483647].
    rng must return float in [0..1]

## ◆ randUint31()

randUint31 | ( |  | rng = random.random | ) |

    returns a random integer in [0..2^31).
    rng must return float in [0..1]

## ◆ reduceAngle()

reduceAngle | ( |  | deg | ) |

    Reduces an angle (in degrees) to a value in [-180..180)

## ◆ replace()

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()

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()

safeRepr | ( |  | obj | ) |

## ◆ safeReprTypeOnFail()

safeReprTypeOnFail | ( |  | obj | ) |

## ◆ safeTypeName()

safeTypeName | ( |  | o | ) |

## ◆ sameElements()

sameElements | ( |  | a,
|  |  | b )

## ◆ serialNum()

serialNum | ( |  | ) |

## ◆ solveQuadratic()

solveQuadratic | ( |  | a,
|  |  | b,
|  |  | c )

## ◆ stackEntryInfo()

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()

startProfile | ( |  | filename = PyUtilProfileDefaultFilename,
|  |  | lines = PyUtilProfileDefaultLines,
|  |  | sorts = PyUtilProfileDefaultSorts,
|  |  | silent = 0,
|  |  | callInfo = 1,
|  |  | useDisk = False,
|  |  | cmd = 'run()' )

## ◆ startSuperLog()

startSuperLog | ( |  | customFunction = None | ) |

## ◆ testAlphabetCounter()

testAlphabetCounter | ( |  | ) |

## ◆ traceFunctionCall()

traceFunctionCall | ( |  | frame | ) |

    return a string that shows the call frame with calling arguments.
    e.g.
    foo(x=234, y=135)

## ◆ traceParentCall()

traceParentCall | ( |  | ) |

## ◆ typeName()

typeName | ( |  | o | ) |

## ◆ unescapeHtmlString()

unescapeHtmlString | ( |  | s | ) |

## ◆ union()

union | ( |  | a,
|  |  | b )

    union(list, list):

## ◆ uniqueElements()

uniqueElements | ( |  | L | ) |

    are all elements of list unique?

## ◆ uniqueName()

uniqueName | ( |  | name | ) |

## ◆ weightedChoice()

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()

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.

## Variable Documentation

## ◆ _KEY_DICT

int _KEY_DICT = 8
| protected

## ◆ _POS_LIST

int _POS_LIST = 4
| protected

## ◆ _ProfileResultStr

str _ProfileResultStr = ''
| protected

## ◆ _resolve_name

_resolve_name
| protected

## ◆ _serialGen

_serialGen = SerialNumGen()
| protected

## ◆ appendStr

appendStr

## ◆ bound

bound

## ◆ clamp

clamp = bound

## ◆ classobj

classobj = classobj

## ◆ configIsToday

configIsToday

## ◆ deeptype

deeptype

## ◆ Default

Default

## ◆ DelayedCall

DelayedCall

## ◆ DelayedFunctor

DelayedFunctor

## ◆ dtoolSuperBase

dtoolSuperBase = None

## ◆ exceptionLogged

exceptionLogged

## ◆ exceptionLoggedNotify

exceptionLoggedNotify = None

## ◆ fastRepr

fastRepr

## ◆ flywheel

flywheel

## ◆ FrameDelayedCall

FrameDelayedCall

## ◆ ftc

ftc = formatTimeCompact

## ◆ fte

fte = formatTimeExact

## ◆ getBase

getBase

## ◆ getRepository

getRepository

## ◆ GoldenRatio

tuple GoldenRatio = (1. + math.sqrt(5.)) / 2.

## ◆ HierarchyException

HierarchyException

## ◆ histogramDict

histogramDict

## ◆ imp

imp = import_module('imp')

## ◆ import_module

import_module

## ◆ importlib

importlib = imp.new_module("importlib")

## ◆ invertDict

invertDict

## ◆ invertDictLossless

invertDictLossless

## ◆ itype

itype

## ◆ lerp

lerp

## ◆ logBlock

logBlock

## ◆ loopGen

loopGen

## ◆ makeList

makeList

## ◆ makeTuple

makeTuple

## ◆ MiniLog

MiniLog

## ◆ MiniLogSentry

MiniLogSentry

## ◆ movedDumpFuncs

list movedDumpFuncs = []

## ◆ movedLoadFuncs

list movedLoadFuncs = []

## ◆ movedOpenFuncs

list movedOpenFuncs = []

## ◆ nullGen

nullGen

## ◆ printReverseStack

printReverseStack

## ◆ printStack

printStack

## ◆ printVerboseStack

printVerboseStack

## ◆ profiled

profiled

## ◆ profileFilename2file

dict profileFilename2file = {}

## ◆ profileFilename2marshalData

dict profileFilename2marshalData = {}

## ◆ profileFilenameList

profileFilenameList = Stack()

## ◆ profileFilenames

profileFilenames = set()

## ◆ pstatcollect

pstatcollect

## ◆ PyUtilProfileDefaultFilename

str PyUtilProfileDefaultFilename = 'profiledata'

## ◆ PyUtilProfileDefaultLines

int PyUtilProfileDefaultLines = 80

## ◆ PyUtilProfileDefaultSorts

list PyUtilProfileDefaultSorts = ['cumulative', 'time', 'calls']

## ◆ rad180

rad180 = math.pi

## ◆ rad270

float rad270 = 1.5 * math.pi

## ◆ rad360

int rad360 = 2. * math.pi

## ◆ rad90

int rad90 = math.pi / 2.

## ◆ report

report

## ◆ safeRepr

safeRepr

## ◆ safeReprNotify

safeReprNotify = None

## ◆ safeTypeName

safeTypeName

## ◆ StackTrace

StackTrace

## ◆ SubframeCall

SubframeCall

## ◆ superLogFile

superLogFile = None

## ◆ typeName

typeName

## ◆ xrange

xrange = range