Standardized versions of various cool things that you can do with
Python's reflection capabilities. This should probably involve
metaclasses somehow, but I don't understand them, so nyah :-)
Imported modules
|
|
import cStringIO
import failure
import os
import pickle
import reference
import string
import sys
import types
|
Functions
|
|
|
|
_reclass
|
_reclass ( clazz )
|
|
_startswith
|
_startswith ( s, sub )
|
|
accumulateBases
|
accumulateBases (
classObj,
l,
baseClass=None,
)
|
|
accumulateClassDict
|
accumulateClassDict (
classObj,
attr,
dict,
baseClass=None,
)
Accumulate all attributes of a given name in a class heirarchy into a single dictionary.
Assuming all class attributes of this name are dictionaries.
If any of the dictionaries being accumulated have the same key, the
one highest in the class heirarchy wins.
(XXX: If "higest" means "closest to the starting class".)
Ex::
| class Soy:
| properties = {"taste": "bland"}
|
| class Plant:
| properties = {"colour": "green"}
|
| class Seaweed(Plant):
| pass
|
| class Lunch(Soy, Seaweed):
| properties = {"vegan": 1 }
|
| dct = {}
|
| accumulateClassDict(Lunch, "properties", dct)
|
| print dct
{"taste": "bland", "colour": "green", "vegan": 1}
|
|
accumulateClassList
|
accumulateClassList (
classObj,
attr,
listObj,
baseClass=None,
)
Accumulate all attributes of a given name in a class heirarchy into a single list.
Assuming all class attributes of this name are lists.
|
|
accumulateMethods
|
accumulateMethods (
obj,
dict,
prefix='',
curClass=None,
)
accumulateMethods(instance, dict, prefix)
I recurse through the bases of instance.__class__, and add methods
beginning with prefix to dict , in the form of
{'methodname':instancemethod_object}.
|
|
addMethodNamesToDict
|
addMethodNamesToDict (
classObj,
dict,
prefix,
baseClass=None,
)
addMethodNamesToDict(classObj, dict, prefix, baseClass=None) -> dict
this goes through classObj (and it's bases) and puts method names
starting with prefix in dict with a value of 1. if baseClass isn't
None, methods will only be added if classObj is-a baseClass If the class in question has the methods prefix_methodname and
prefix_methodname2 , the resulting dict should look something like:
{"methodname": 1, "methodname2": 1}.
|
|
allYourBase
|
allYourBase ( classObj, baseClass=None )
allYourBase(classObj, baseClass=None) -> list of all base
classes that are subclasses of baseClass, unless it is None,
in which case all bases will be added.
|
|
currentThread
|
currentThread ()
|
|
filenameToModuleName
|
filenameToModuleName ( fn )
Convert a name in the filesystem to the name of the Python module it is.
This is agressive about getting a module name back from a file; it will
always return a string. Agressive means 'sometimes wrong'; it won't look
at the Python path or try to do any error checking: don't use this method
unless you already know that the filename you're talking about is a Python
module.
|
|
findInstances
|
findInstances ( start, t )
|
|
fullFuncName
|
fullFuncName ( func )
|
|
funcinfo
|
funcinfo ( function )
this is more documentation for myself than useful code.
|
|
getcurrent
|
getcurrent ( clazz )
|
|
isLike
|
isLike ( a, b )
|
|
isOfType
|
isOfType ( start, goal )
|
|
isSame
|
isSame ( a, b )
|
|
isinst
|
isinst ( inst, clazz )
|
|
macro
|
macro (
name,
filename,
source,
**identifiers,
)
macro(name, source, **identifiers)
This allows you to create macro-like behaviors in python. See
twisted.python.hook for an example of its usage.
|
|
modgrep
|
modgrep ( goal )
|
|
namedModule
|
namedModule ( name )
Return a module give it's name.
|
|
namedObject
|
namedObject ( name )
Get a fully named module-global object.
|
|
objgrep
|
objgrep (
start,
goal,
eq=isLike,
path='',
paths=None,
seen=None,
)
An insanely CPU-intensive process for finding stuff.
|
|
prefixedMethodNames
|
prefixedMethodNames ( classObj, prefix )
A list of method names with a given prefix in a given class.
|
|
prefixedMethods
|
prefixedMethods ( obj, prefix )
A list of methods with a given prefix on a given instance.
|
|
qual
|
qual ( clazz )
|
|
refrump
|
refrump ( obj )
|
|
safe_repr
|
safe_repr ( obj )
safe_repr(anything) -> string
Returns a string representation of an object (or a traceback, if that
object's __repr__ raised an exception)
|
Classes
|
|
Accessor |
Extending this class will give you explicit accessor methods; a
|
Promise |
I represent an object not yet available.
|
QueueMethod |
I represent a method that doesn't exist yet.
|
Settable |
A mixin class for syntactic sugar. Lets you assign attributes by
|
Summer |
Extend from this class to get the capability to maintain 'related
|
ThreadAttr | |
|
|