def addHandler(self, comparator, callback):
"""Adds a handler to the SerialListener
Throws ValueError: on invalid arguments
comparator is either True or a function. That function must return a
boolean value when passed the message in question. callback is a
function that is called iff the comparator returns True and is also
passed the msg.
"""
# Make sure that the comparator is either a function or a boolean
if not (inspect.isfunction(comparator) or inspect.ismethod(comparator) or isinstance(comparator, bool)):
raise ValueError("Invalid comparator passed to addHandler, must be a function or boolean")
# If comparator is a function check to make sure it takes atleast 1 argument beyond self
if inspect.isfunction(comparator) or inspect.ismethod(comparator):
args = inspect.getargspec(comparator).args
try:
args.remove("self")
except:
pass
if len(args) == 0:
raise ValueError("Invalid comparator passed to addHandler, must take atleast one argument")
# Make sure that the callback is a function
if not (inspect.isfunction(callback) or inspect.ismethod(callback)):
raise ValueError("Invalid callback passed to addHandler, must be a function")
else:
# Make sure it has atleast one argument for the msg
args = inspect.getargspec(callback).args
try:
args.remove("self")
except:
pass
if len(args) == 0:
raise ValueError("Invalid callback passed to addHandler, must take atleast one argument")
self.handlers.append((comparator, callback))
def testInit(self):
"""
Tests __init__() behavior on invalid values
"""
for name in (None, "", "name"):
for value in (None, "", "value"):
for comparator in (None, True, lambda x: True):
if not all((name, value, comparator)) \
or (not inspect.isfunction(comparator)
and not inspect.ismethod(comparator)):
# One value is None
self.assertRaises(ValueError,
pelix.ldapfilter.LDAPCriteria, name,
value, comparator)
else:
# All values are OK
criteria = pelix.ldapfilter.LDAPCriteria(name, value,
comparator)
self.assertEqual(name, criteria.name,
"Name modified")
self.assertEqual(value, criteria.value,
"Value modified")
self.assertTrue(
inspect.ismethod(criteria.comparator)
or inspect.isfunction(criteria.comparator),
"Invalid comparator accepted")
def print_classes():
for name, obj in inspect.getmembers(jb):
if inspect.isclass(obj):
#f1.write('paichi_the_found'
f1.write('\n')
f1.write("Class Name -> "+name)
f1.write('\n')
for N, O in inspect.getmembers(obj):
#f1.write(' --- Extra --- '
if inspect.isclass(O):
f1.write(" "+"SubClass Name -> "+N)
f1.write('\n')
if inspect.ismethod(O):
f1.write(" "+"SubMethod Name -> "+N)
f1.write('\n')
if inspect.isfunction(O):
f1.write(" "+"SubFunction Name -> "+N)
f1.write('\n')
if inspect.ismethod(obj):
#f1.write('paichi_the_found'
f1.write('')
f1.write('\n')
f1.write("Method Name -> "+name)
f1.write('\n')
if inspect.isfunction(obj):
#f1.write('paichi_the_found'
f1.write('')
f1.write('\n')
f1.write("Function Name -> "+name)
f1.write('\n')
def __init__(self, name, func, args, kwargs):
"""
Maintains node evaluation state for basic node types.
:param name: Name of the node.
:param func: A function, method or callable class instance.
:param args: Positional arguments that will be passed to the function for evaluation.
:param kwargs: Keyword arguments that will be passed to the function for evaluation.
"""
super(NodeState, self).__init__(name, func)
# If the func object is not a method or a function, assume it is a callable class
if inspect.isclass(type(func)) and not inspect.ismethod(func) and not inspect.isfunction(func):
self.func = func.__call__
args_spec = inspect.getargspec(self.func)
args_spec_args = args_spec.args
# Exclude `self` for class methods
if inspect.ismethod(self.func):
args_spec_args = args_spec_args[1:]
self._args_spec = NodeArgSpec(args_spec_args, args_spec.varargs, args_spec.keywords)
self._args = args
self._kwargs = kwargs
def wrapper(self, *args, **kw):
if hasattr(self, 'before') and inspect.ismethod(self.before):
self.before()
result = f(self, *args, **kw)
if hasattr(self, 'after') and inspect.ismethod(self.after):
self.after()
return result
def delete_card(self, data):
profile_id = data.profile.id
if inspect.ismethod(profile_id):
err_msg = "Profile Id not available"
return (self.prepare_error(CustomerVault.Card.Card,
"400",
err_msg))
del data.profile
card_id = data.id
if inspect.ismethod(card_id):
err_msg = "Card Id not available"
return (self.prepare_error(CustomerVault.Card.Card,
"400",
err_msg))
del data.id
FULL_URL = self._prepare_uri(self._PROFILE_PATH + \
profile_id + \
self._CARD_PATH + \
card_id)
# print ("Communicating to ", FULL_URL)
response = self.optimal_object.process_request(
req_method="DELETE",
url=FULL_URL,
data=None)
return (self._process_response(response,
CustomerVault.Card.Card))
def lookup_sepa_bank_account(self, data):
profile_id = data.profile.id
if inspect.ismethod(profile_id):
err_msg = "Profile Id not available"
return (self.prepare_error(CustomerVault.SEPABankAccount.SEPABankAccount,
"400",
err_msg))
del data.profile
sepa_bank_id = data.id
if inspect.ismethod(sepa_bank_id):
err_msg = "SEPA Bank Account Id not available"
return (self.prepare_error(
CustomerVault.SEPABankAccount.SEPABankAccount,
"400",
err_msg))
del data.id
FULL_URL = self._prepare_uri(self._PROFILE_PATH + \
profile_id + \
self._SEPA_BANK_PATH + \
sepa_bank_id)
# print ("Communicating to ", FULL_URL)
response = self.optimal_object.process_request(
req_method="GET",
url=FULL_URL,
data=None)
return (self._process_response(response, CustomerVault.SEPABankAccount.SEPABankAccount))
def update_mandates(self, data):
profile_id = data.profile.id
mandates_id = data.id
if inspect.ismethod(profile_id):
err_msg = "Profile Id not available"
return (self.prepare_error(
CustomerVault.Mandates.Mandates,
"400",
err_msg))
del data.profile
if inspect.ismethod(mandates_id):
err_msg = "Mandates Id not available"
return (self.prepare_error(
CustomerVault.Mandates.Mandates,
"400",
err_msg))
del data.id
FULL_URL = self._prepare_uri(self._PROFILE_PATH + \
profile_id + \
self._MANDATES_PATH +\
self._URI_SEPARATOR +\
mandates_id)
# print ("Communicating to ", FULL_URL)
response = self.optimal_object.process_request(
req_method="PUT",
url=FULL_URL,
data=data)
return (self._process_response(response, CustomerVault.Mandates.Mandates))
def delete_address(self, data):
profile_id = data.profile.id
if inspect.ismethod(profile_id):
err_msg = "Profile Id not available"
return (self.prepare_error(CustomerVault.Addresses.Address,
"400",
err_msg))
del data.profile
address_id = data.id
if inspect.ismethod(address_id):
err_msg = "Address Id not available"
return (self.prepare_error(CustomerVault.Addresses.Address,
"400",
err_msg))
del data.id
FULL_URL = self._prepare_uri(self._PROFILE_PATH + \
profile_id + \
self._ADDRESS_PATH + \
address_id)
# print ("Communicating to ", FULL_URL)
response = self.optimal_object.process_request(
req_method="DELETE",
url=FULL_URL,
data=None)
return (self._process_response(response,
CustomerVault.Addresses.Address))
def _ListAllSubprocesses():
try:
import psutil
except ImportError:
logging.warning(
'psutil is not installed on the system. Not listing possible '
'leaked processes. To install psutil, see: '
'https://pypi.python.org/pypi/psutil')
return
telemetry_pid = os.getpid()
parent = psutil.Process(telemetry_pid)
if hasattr(parent, 'children'):
children = parent.children(recursive=True)
else: # Some old version of psutil use get_children instead children.
children = parent.get_children()
if children:
leak_processes_info = []
for p in children:
if inspect.ismethod(p.name):
name = p.name()
else: # Process.name is a property in old versions of psutil.
name = p.name
process_info = '%s (%s)' % (name, p.pid)
try:
if inspect.ismethod(p.cmdline):
cmdline = p.cmdline()
else:
cmdline = p.cmdline
process_info += ' - %s' % cmdline
except Exception as e:
logging.warning(str(e))
leak_processes_info.append(process_info)
logging.error('Telemetry leaks these processes: %s',
', '.join(leak_processes_info))
def create_mandates_sepa_bank(self, data):
profile_id = data.profile.id
sepa_bank_id = data.sepa.id
if inspect.ismethod(profile_id):
err_msg = "Profile Id not available"
return (self.prepare_error(
CustomerVault.Mandates.Mandates,
"400",
err_msg))
del data.profile
if inspect.ismethod(sepa_bank_id):
err_msg = "SEPA Bank Account Id not available"
return (self.prepare_error(
CustomerVault.Mandates.Mandates,
"400",
err_msg))
del data.sepa
FULL_URL = self._prepare_uri(self._PROFILE_PATH +\
profile_id +\
self._SEPA_BANK_PATH +\
sepa_bank_id +\
self._MANDATES_PATH)
# print ("Communicating to ", FULL_URL)
response = self.optimal_object.process_request(
req_method="POST",
url=FULL_URL,
data=data)
return (self._process_response(response, CustomerVault.Mandates.Mandates))
def __init__(self, *check, **kwargs):
"""
@keyword default: value/ function that will be
assigned/called if prop value is requested but is None.
@keyword reset: value/function that will be assigned/called on
initialization
@keyword blurb: Short description.
@keyword doc: Longer description.
"""
self.blurb = kwargs.pop('blurb', None)
self.doc = kwargs.pop('doc', None)
self.check = CheckAll(check or [])
default = kwargs.pop('default', None)
if inspect.isfunction(default) or inspect.ismethod(default):
self.on_default = default
else:
if default is not None:
default = self.check(default)
self.on_default = (lambda: default)
reset = kwargs.pop('reset', None)
if inspect.isfunction(reset) or inspect.ismethod(reset):
self.on_reset = reset
else:
if reset is not None:
reset = self.check(reset)
self.on_reset = (lambda: reset)
self.name = None # set by the owning HasProps class
def _get_all_props(self):
'return all properties accessible through get'
all_props = []
# release properties
rel_props = getmembers(self.release,
predicate=lambda p: (not ismethod(p)))
rel_props = [a[0] for a in rel_props if not a[0].startswith('_')]
all_props.extend(rel_props)
# element_type properties
et_props = getmembers(self.element_type,
predicate=lambda p: (not ismethod(p)))
'remove _state - update this after we change _state to _state'
et_props = [a[0] for a in et_props
if not a[0].startswith('_') and a[0] != '_state']
all_props.extend(et_props)
# properties for each of the initializer objects
i_props = []
for val in self.element_type.initializers:
toadd = getmembers(val, lambda p: (not ismethod(p)))
i_props.extend([a[0] for a in toadd
if not a[0].startswith('_') and a[0] != '_state'])
all_props.extend(i_props)
return all_props
def isstaticmethod(obj):
# python2:
# >>> str(object)
# <function staticmethod at ...>
# python3
# >>> str(object)
# <function CLS.staticmethod at ...>
if not obj_check(obj):
return False
module = inspect.getmodule(obj)
if not module:
return False
try:
lines, _ = inspect.getsourcelines(obj)
if lines:
if "staticmethod" not in "\n".join(lines):
return False
if lines[0].lstrip() == "@staticmethod":
return True
except Exception:
pass
# python 2: <function staticmethod at ...>
if "<function staticmethod at" in str(obj):
return True
# python 3: <function CLS.staticmethod at ...>
if "<function " in str(obj) and "." in str(obj):
return True
for _, cls in inspect.getmembers(module, inspect.isclass):
for _, member in inspect.getmembers(cls, inspect.isroutine):
if inspect.ismethod(member):
continue
if member == obj:
# python 2 only
return not inspect.ismethod(obj)
return False
def _call_partial(function, args, kwargs, require_event=False):
"""
Add args and kwargs when calling function (similar to functools.partial).
Also, allow omission of the first argument (event) if require_event
is False.
"""
try:
argspec = _inspect.getargspec(function)
ismethod = _inspect.ismethod(function)
except TypeError:
# support callable objects
argspec = _inspect.getargspec(function.__call__)
ismethod = _inspect.ismethod(function.__call__)
if (not require_event and argspec[1] == None
and len(argspec[0]) - int(ismethod) == 0):
# omit event argument when function has no positional arguments
if len(kwargs):
return lambda ev: function(**kwargs)
else:
return lambda ev: function()
if len(args) or len(kwargs):
# return a function with args and kwargs applied
return lambda ev: function(ev, *args, **kwargs)
else:
# no additional arguments, no wrapper needed
return function
def varnames(func):
""" return argument name tuple for a function, method, class or callable.
In case of a class, its "__init__" method is considered.
For methods the "self" parameter is not included unless you are passing
an unbound method with Python3 (which has no supports for unbound methods)
"""
cache = getattr(func, "__dict__", {})
try:
return cache["_varnames"]
except KeyError:
pass
if inspect.isclass(func):
try:
func = func.__init__
except AttributeError:
return ()
ismethod = True
else:
if not inspect.isfunction(func) and not inspect.ismethod(func):
func = getattr(func, '__call__', func)
ismethod = inspect.ismethod(func)
rawcode = py.code.getrawcode(func)
try:
x = rawcode.co_varnames[ismethod:rawcode.co_argcount]
except AttributeError:
x = ()
try:
cache["_varnames"] = x
except TypeError:
pass
return x
def _finddoc(obj):
# type: (Any) -> unicode
if inspect.isclass(obj):
for base in obj.__mro__:
if base is not object:
try:
doc = base.__doc__
except AttributeError:
continue
if doc is not None:
return doc
return None
if inspect.ismethod(obj) and getattr(obj, '__self__', None):
name = obj.__func__.__name__
self = obj.__self__
if (inspect.isclass(self) and
getattr(getattr(self, name, None), '__func__')
is obj.__func__):
# classmethod
cls = self
else:
cls = self.__class__
elif inspect.isfunction(obj) or inspect.ismethod(obj):
name = obj.__name__
cls = _findclass(obj)
if cls is None or getattr(cls, name) != obj:
return None
elif inspect.isbuiltin(obj):
name = obj.__name__
self = obj.__self__
if (inspect.isclass(self) and
self.__qualname__ + '.' + name == obj.__qualname__):
# classmethod
cls = self
else:
cls = self.__class__
# Should be tested before isdatadescriptor().
elif isinstance(obj, property):
func = obj.fget
name = func.__name__
cls = _findclass(func)
if cls is None or getattr(cls, name) is not obj:
return None
elif inspect.ismethoddescriptor(obj) or inspect.isdatadescriptor(obj):
name = obj.__name__
cls = obj.__objclass__
if getattr(cls, name) is not obj:
return None
else:
return None
for base in cls.__mro__:
try:
doc = getattr(base, name).__doc__
except AttributeError:
continue
if doc is not None:
return doc
return None
def _func_name(func):
"""Return name of a callable (function, class, partial, etc.)"""
module = ''
if hasattr(func,'__module__'):
module = (func.__module__ if func.__module__ else '__main__')
# Return a human readable name associated with a function
if inspect.ismethod(func):
nme = '.'.join([module,func.im_class.__name__,func.__name__])
elif inspect.isfunction(func):
nme = '.'.join([module,func.__name__])
elif inspect.isbuiltin(func):
return '.'.join([module,func.__name__])
elif isinstance(func,partial):
return 'partial_of_' + JobModule._func_name(func.func)
elif inspect.isclass(func):
nme = '.'.join([module,func.__name__])
if hasattr(func, '__init__') and inspect.ismethod(func.__init__):
func = func.__init__
else:
return nme
else:
nme = 'type %s' % type(func)
if hasattr(func, '__name__'):
nme = '%s of %s' % (func.__name__, type(func))
return nme
nme += ' at ' + ':'.join([func.func_code.co_filename,
str(func.func_code.co_firstlineno)])
return nme
def parseCallable(targetCall, name, user_args, user_kwargs):
'''
'''
#
# Check callable given
#
import inspect
if not (inspect.ismethod(targetCall) or inspect.isfunction(targetCall)):
raise GraphError("Callable must be a function or method.")
# Common args
callableArgs = {}
callableArgs['sysPath'] = sys.path
callableArgs['moduleName'] = targetCall.__module__
# Ensure params can be serialized i.e. not object, instance or function
try:
callableArgs['user_args'] = json.dumps(user_args)
callableArgs['user_kwargs'] = json.dumps(user_kwargs)
except TypeError:
raise GraphError("Error: invalid parameters (not JSON serializable): %s" % params)
# Specific args
if inspect.isfunction(targetCall):
callableArgs['execType'] = 'function'
callableArgs['funcName'] = targetCall.__name__
taskName = name if name != "" else callableArgs['funcName']
if inspect.ismethod(targetCall):
callableArgs['execType'] = 'method'
callableArgs['className'] = inspect.getmro(targetCall.im_class)[0].__name__
callableArgs['methodName'] = targetCall.__name__
taskName = name if name != "" else callableArgs['className'] + "." + callableArgs['methodName']
return (taskName, callableArgs)
def __call__(self, *args, **kwargs):
transaction = newrelic.api.transaction.current_transaction()
if not transaction:
return self._nr_next_object(*args, **kwargs)
if callable(self._nr_library):
if self._nr_instance and inspect.ismethod(self._nr_next_object):
library = self._nr_library(self._nr_instance, *args,
**kwargs)
else:
library = self._nr_library(*args, **kwargs)
else:
library = self._nr_library
if callable(self._nr_command):
if self._nr_instance and inspect.ismethod(self._nr_next_object):
command = self._nr_command(self._nr_instance, *args,
**kwargs)
else:
command = self._nr_command(*args, **kwargs)
else:
command = self._nr_command
with SolrTrace(transaction, library, command):
return self._nr_next_object(*args, **kwargs)
def wrapper(*args, **kwargs):
name, my_args = function.__name__, args
if inspect.ismethod(function):
name = function.__self__.__class__.__name__ + '.' + function.__name__
elif len(args):
members = dict(inspect.getmembers(args[0], predicate = lambda _: inspect.ismethod(_) and _.__name__ == function.__name__))
logger.debug('members.keys(): %s', members.keys())
if len(members):
name, my_args = args[0].__class__.__name__ + '.' + function.__name__, args[1:]
format_args = (
prefix + name,
', '.join(list(map(str, my_args)) + [ ' = '.join(map(str, item)) for item in kwargs.items() ]),
)
logger.info('STARTING: %s(%s)', *format_args)
try:
return function(*args, **kwargs)
except:
logger.exception('EXCEPTION: %s(%s)', *format_args)
raise
finally:
logger.info('STOPPING: %s(%s)', *format_args)
def getRulesAndTokens(parsercls):
"""
build the tokens and precedence tuples from inherited declarations.
gather tokens and rules definition from Parser class members (own and inherited)
"""
tokensDict = {}
rulesDict = {}
for name, obj in inspect.getmembers(parsercls):
if name.startswith("t_") and name != "t_error":
if isinstance(obj, basestring):
v = obj
elif inspect.isfunction(obj) or inspect.ismethod(obj):
v = obj.__doc__
else:
raise SyntaxError, "Token definition %s defines neither a string nor a function, unable to parse" % m[
0
]
k = name[2:]
tokensDict[k] = obj
elif name.startswith("p_") and inspect.ismethod(obj) and name != "p_error":
k = name[2:]
rulesDict[k] = obj
# elif name == '_reserved' and isinstance(obj,dict):
# # reserved attribute holds a list of reserved token keywords.
# # these should only exist on
# print "FOUND reserved!"
# for k,v in obj.items():
# tokensDict[v]=None
return rulesDict, tokensDict
def detectCapabilities():
body = {}
precon = {}
try:
import capability
from inspect import getmembers, isclass, ismethod
for m in filter( lambda x: not x.startswith('__'), dir(capability) ):
for c in getmembers( eval('capability.' + m), isclass ):
d_b = dict(getmembers(c[1],lambda x: ismethod(x) and 'SDMethodType' in dir(x) and x.SDMethodType == 'body'))
d_p = dict(getmembers(c[1],lambda x: ismethod(x) and 'SDMethodType' in dir(x) and x.SDMethodType == 'pre'))
if d_b:
if '__init__' in d_b.keys():
del d_b['__init__']
body[c[0]] = d_b
if d_p:
if '__init__' in d_p.keys():
del d_p['__init__']
precon[c[0]] = d_p
#del getmembers, isclass, ismethod
except Exception, x:
print "Error detecting capabilities: "
print str(x)
def test_model_schema(self):
""" Test that there's a proper schema spec on `Model` """
# check lookup
self.assertTrue(hasattr(TestPerson, '__lookup__'))
self.assertIsInstance(TestPerson.__lookup__, frozenset)
# check property descriptors
self.assertTrue(hasattr(TestPerson, 'firstname'))
self.assertTrue(hasattr(TestPerson, 'lastname'))
self.assertTrue(hasattr(TestPerson, 'cars'))
# check kind
self.assertTrue(hasattr(TestPerson, 'kind'))
self.assertIsInstance(TestPerson.kind(), basestring)
# check set/get
self.assertTrue(hasattr(TestPerson, '_get_value'))
self.assertTrue(hasattr(TestPerson, '_set_value'))
self.assertTrue(inspect.ismethod(TestPerson._get_value))
self.assertTrue(inspect.ismethod(TestPerson._set_value))
# check key
self.assertTrue(hasattr(TestPerson, 'key'))
self.assertTrue(hasattr(TestPerson(), '__key__'))
# should not have key until instantiation
self.assertTrue((not hasattr(TestPerson, '__key__')))
def objects_link(name='', description=None, model=None):
"""
Create a function that can be attached to a ModelAdmin to use
as a list_display field
"""
related_names = name.split('__')
def getter(self, obj):
if not related_names[0]:
return obj.link()
for related_name in related_names:
obj = getattr(obj, related_name)
if inspect.ismethod(obj): # Is a method
obj = obj()
return render_to_string(
'includes/objects_link.html',
{
'objects': obj.all()
}
)
for related_name in related_names:
field = model
if hasattr(model, "_meta"):
related_name = related_name.replace("_set", "")
if related_name in model._meta.fields_map:
model = model._meta.fields_map[related_name]
elif inspect.ismethod(model): # Is a method
getter.short_description = description \
or getattr(model, related_name).short_description
return getter
else:
if inspect.ismethod(getattr(model, related_name)):
getter.short_description = description \
or getattr(model, related_name).short_description
return getter
else:
model = getattr(model, related_name).field
getter.short_description = description \
or _(model.verbose_name.title())
return getter
if model.get_internal_type() in [
"ForeignKey", "ManyToManyField"
]:
model = model.related_model
getter.short_description = description \
or _(model._meta.verbose_name_plural.title())
else:
getter.short_description = description \
or _(field._meta.verbose_name_plural.title())
getter.allow_tags = True
return getter
def getMethods(self):
# remove the security proxy, so that `attr` is not proxied. We could
# unproxy `attr` for each turn, but that would be less efficient.
#
# `getPermissionIds()` also expects the class's security checker not
# to be proxied.
klass = zope.security.proxy.removeSecurityProxy(self.klassView.context)
obj = zope.security.proxy.removeSecurityProxy(self.context)
for name in apidoc.utilities.getPublicAttributes(obj):
val = getattr(obj, name)
if not (inspect.ismethod(val) or inspect.ismethoddescriptor(val)):
continue
if inspect.ismethod(val):
signature = apidoc.utilities.getFunctionSignature(val)
else:
signature = '(...)'
entry = {
'name': name,
'signature': signature,
'doc': apidoc.utilities.renderText(
val.__doc__ or '',
zapi.getParent(self.klassView.context).getPath()),
'interface': apidoc.utilities.getInterfaceForAttribute(
name, klass._Class__all_ifaces)}
entry.update(apidoc.utilities.getPermissionIds(
name, klass.getSecurityChecker()))
yield entry
def _find_sub_controllers(self, remainder):
"""
Identifies the correct controller to route to by analyzing the
request URI.
"""
# need either a get_one or get to parse args
method = None
for name in ("get_one", "get"):
if hasattr(self, name):
method = name
break
if not method:
return
# get the args to figure out how much to chop off
args = getargspec(getattr(self, method))
fixed_args = len(args[0][1:]) - len(request.pecan.get("routing_args", []))
var_args = args[1]
# attempt to locate a sub-controller
if var_args:
for i, item in enumerate(remainder):
controller = getattr(self, item, None)
if controller and not ismethod(controller):
self._set_routing_args(remainder[:i])
return lookup_controller(controller, remainder[i + 1 :])
elif fixed_args < len(remainder) and hasattr(self, remainder[fixed_args]):
controller = getattr(self, remainder[fixed_args])
if not ismethod(controller):
self._set_routing_args(remainder[:fixed_args])
return lookup_controller(controller, remainder[fixed_args + 1 :])
def dynamic_wrapper(wrapped, instance, args, kwargs):
transaction = current_transaction()
if transaction is None:
return wrapped(*args, **kwargs)
if callable(url):
if instance and inspect.ismethod(wrapped):
_url = url(instance, *args, **kwargs)
else:
_url = url(*args, **kwargs)
else:
_url = url
if callable(method):
if instance and inspect.ismethod(wrapped):
_method = method(instance, *args, **kwargs)
else:
_method = method(*args, **kwargs)
else:
_method = method
with ExternalTrace(transaction, library, _url, _method):
return wrapped(*args, **kwargs)
def flexapply(handler, args, kwargs):
if inspect.isfunction(handler) or inspect.ismethod(handler):
if inspect.ismethod(handler) and handler.im_self is not None:
args = (handler.im_self, ) + args
handler = handler.im_func
args, kwargs = buildargs(handler, args, kwargs)
return handler(*args, **kwargs)
def getexpected(func):
"""
Returns as a 2-tuple the passed in object's expected arguments and
whether or not it accepts variable keywords.
"""
assert callable(func), 'object not callable'
if not inspect.isclass(func):
# At this point, we assume func is either a function, method, or
# callable instance.
if not inspect.isfunction(func) and not inspect.ismethod(func):
func = getattr(func, '__call__') # When would this fail?
argspec = inspect.getargspec(func)
expected, varkw = argspec[0], argspec[2] is not None
if inspect.ismethod(func):
expected = expected[1:]
else:
# A class. Try to figure out the calling conventions of the
# constructor.
init = getattr(func, '__init__', None)
# Sigh, this is getting into the realm of black magic...
if init is not None and inspect.ismethod(init):
argspec = inspect.getargspec(init)
expected, varkw = argspec[0], argspec[2] is not None
expected = expected[1:]
else:
expected, varkw = [], False
return expected, varkw
def get_public_fields(obj):
return [
attr for attr in dir(obj)
if not (attr.startswith("_") or inspect.isbuiltin(attr)
or inspect.isfunction(attr) or inspect.ismethod(attr))
]
def check_validity_of_input(self, method):
if not inspect.ismethod(method):
raise Exception("Whoops, looks like you accidentally invoked "
"the method you want to animate")
assert (isinstance(method.__self__, Mobject))
def _get_handler_methods(lib):
attrs = [getattr(lib, a) for a in dir(lib) if not a.startswith('_')]
return [a for a in attrs if inspect.ismethod(a)]
def _generate_blobs(self):
"""
Create a list of blobs, one per blob group.
..note:: This should only be run for individual simulations,
not in the analysis of MCMC data.
Returns
-------
List, where each element has shape (ivar x blobs). Each element of
this corresponds to the blobs for one blob group, which is defined by
either its dimensionality, its independent variables, or both.
For example, for 1-D blobs, self.blobs[i][j][k] would mean
i = blob group
j = index corresponding to elements of self.blob_names
k = index corresponding to elements of self.blob_ivars[i]
"""
self._blobs = []
for i, element in enumerate(self.blob_names):
this_group = []
for j, key in enumerate(element):
# 0-D blobs. Need to know name of attribute where stored!
if self.blob_nd[i] == 0:
if self.blob_funcs[i][j] is None:
# Assume blob name is the attribute
#blob = self.__getattribute__(key)
blob = parse_attribute(key, self)
else:
fname = self.blob_funcs[i][j]
# In this case, the return of parse_attribute is
# a value, not a function to be applied to ivars.
blob = parse_attribute(fname, self)
# 1-D blobs. Assume the independent variable is redshift
# unless a function is provided
elif self.blob_nd[i] == 1:
# The 0 index is because ivars are kept in a list no
# matter what
x = np.array(self.blob_ivars[i][0]).squeeze()
if (self.blob_funcs[i][j] is None) and (key
in self.history):
blob = np.interp(x, self.history['z'][-1::-1],
self.history[key][-1::-1])
elif self.blob_funcs[i][j] is None:
raise KeyError('Blob {!s} not in history!'.format(key))
else:
fname = self.blob_funcs[i][j]
# Name of independent variable
xn = self.blob_ivarn[i][0]
if isinstance(fname, basestring):
func = parse_attribute(fname, self)
else:
print('hey {!s}'.format(fname))
raise ValueError('pretty sure this is broken!')
# fname is a slice, like ('igm_k_heat', 0)
# to retrieve heating rate from H ionizations
_xx = self.history['z'][-1::-1]
_yy = self.history[fname[0]][-1::-1, fname[1]]
func = (_xx, _yy)
if ismethod(func) or isinstance(func, interp1d) or \
(type(func) == FunctionType) \
or hasattr(func, '__call__'):
try:
if self.blob_kwargs[i] is not None:
kw = self.blob_kwargs[i][j]
else:
kw = {}
def func_kw(xx):
_kw = kw.copy()
_kw.update({xn: xx})
return func(**_kw)
blob = np.array([func_kw(xx) for xx in x])
except TypeError:
blob = np.array(list(map(func, x)))
else:
blob = np.interp(x, func[0], func[1])
else:
# Must have blob_funcs for this case
fname = self.blob_funcs[i][j]
tmp_f = parse_attribute(fname, self)
xarr, yarr = list(map(np.array, self.blob_ivars[i]))
if (type(tmp_f) is FunctionType) or ismethod(tmp_f) \
or hasattr(func, '__call__'):
func = tmp_f
elif type(tmp_f) is tuple:
z, E, flux = tmp_f
func = RectBivariateSpline(z, E, flux)
else:
raise TypeError(
'Sorry: don\'t understand blob {!s}'.format(key))
xn, yn = self.blob_ivarn[i]
blob = []
# We're assuming that the functions are vectorized.
# Didn't used to, but it speeds things up (a lot).
for x in xarr:
tmp = []
if self.blob_kwargs[i] is not None:
kw = self.blob_kwargs[i][j]
else:
kw = {}
kw.update({xn: x, yn: yarr})
result = func(**kw)
# Happens when we save a blob that isn't actually
# a PQ (i.e., just a constant). Need to kludge so it
# doesn't crash.
if type(result) in [int, float, np.float64]:
result = result * np.ones_like(yarr)
tmp.extend(result)
blob.append(tmp)
this_group.append(np.array(blob))
self._blobs.append(np.array(this_group))
def trace_call(self, frame, event, arg):
log.info('Trace call (co_name=%s)' % get_co_name(frame))
# retrieve the object for the function being called
func_obj = get_function_obj(frame,
src_lines=self.src_lines,
filename=self.file_path)
# either not a function call (e.g. entered code block)
# or couldn't retrieve function source to get object
if func_obj is None:
log.info('Function object was None for source: %s' %
self._getsource(frame))
if self._defined_by_user(frame):
log.info('Tracing as defined by user')
return self.trace
else:
log.info(
'Ignoring and treating as external since not defined by user'
)
log.info('Function from frame: %s' % get_co_name(frame))
return None
if is_stub_call(func_obj):
log.info('Function object is a stub: %s' % get_co_name(frame))
return self.trace_stub(func_obj, frame, event, arg)
log.info('Collecting call made by user for: %s' % func_obj)
# # increase the depth of the traced stack
self.traced_stack_depth += 1
caller_frame = get_caller_frame(frame)
call_site_lineno = inspect.getlineno(caller_frame)
call_site_line = self._getsource(caller_frame)
# call details
is_method = inspect.ismethod(func_obj)
co_name = get_co_name(frame)
qualname = get_function_qual_name(func_obj)
module = get_function_module(func_obj)
call_args = inspect.getargvalues(frame)
abstract_call_args = get_abstract_vals(call_args)
# we keep track of the memory location of the function object
# because it can allow us to establish a link between a line that calls
# an function and the actual function call entry
mem_loc_func = safe_id(func_obj)
details = dict(
is_method=is_method,
co_name=co_name,
qualname=qualname,
module=module,
abstract_call_args=abstract_call_args,
mem_loc_func=mem_loc_func,
called_by_user=self._called_by_user(frame),
defined_by_user=self._defined_by_user(frame),
)
event_id = self._allocate_event_id()
trace_event = EnterCall(event_id, call_site_lineno, call_site_line,
details)
log.info('Appending trace event: %s' % trace_event)
self.push_trace_event(trace_event)
return self.trace
def use_np_array(func):
"""A decorator wrapping Gluon `Block`s and all its methods, properties, and static functions
with the semantics of NumPy-array, which means that where ndarrays are created,
`mxnet.numpy.ndarray`s should be created, instead of legacy ndarrays of type `mx.nd.NDArray`.
For example, at the time when a parameter is created in a `Block`, an `mxnet.numpy.ndarray`
is created if it's decorated with this decorator.
Example::
import mxnet as mx
from mxnet import gluon, np
class TestHybridBlock1(gluon.HybridBlock):
def __init__(self):
super(TestHybridBlock1, self).__init__()
self.w = self.params.get('w', shape=(2, 2))
def hybrid_forward(self, F, x, w):
return F.dot(x, w)
x = mx.nd.ones((2, 2))
net1 = TestHybridBlock1()
net1.initialize()
out = net1.forward(x)
for _, v in net1.collect_params().items():
assert type(v.data()) is mx.nd.NDArray
assert type(out) is mx.nd.NDArray
@np.use_np_array
class TestHybridBlock2(gluon.HybridBlock):
def __init__(self):
super(TestHybridBlock2, self).__init__()
self.w = self.params.get('w', shape=(2, 2))
def hybrid_forward(self, F, x, w):
return F.np.dot(x, w)
x = np.ones((2, 2))
net2 = TestHybridBlock2()
net2.initialize()
out = net2.forward(x)
for _, v in net2.collect_params().items():
print(type(v.data()))
assert type(v.data()) is np.ndarray
assert type(out) is np.ndarray
Parameters
----------
func : a user-provided callable function or class to be scoped by the NumPy-array semantics.
Returns
-------
Function or class
A function or class wrapped in the NumPy-array scope.
"""
if inspect.isclass(func):
for name, method in inspect.getmembers(
func,
predicate=lambda f: inspect.isfunction(f) or inspect.ismethod(
f) or isinstance(f, property)):
if isinstance(method, property):
setattr(
func, name,
property(use_np_array(method.__get__), method.__set__,
method.__delattr__, method.__doc__))
else:
setattr(func, name, use_np_array(method))
return func
elif callable(func):
@functools.wraps(func)
def _with_np_array(*args, **kwargs):
with np_array(active=True):
return func(*args, **kwargs)
return _with_np_array
else:
raise TypeError(
'use_np_array can only decorate classes and callable objects, '
'while received a {}'.format(str(type(func))))
def use_np_shape(func):
"""A decorator wrapping a function or class with activated NumPy-shape semantics.
When `func` is a function, this ensures that the execution of the function is scoped with NumPy
shape semantics, such as the support for zero-dim and zero size tensors. When
`func` is a class, it ensures that all the methods, static functions, and properties
of the class are executed with the NumPy shape semantics.
Example::
import mxnet as mx
@mx.use_np_shape
def scalar_one():
return mx.nd.ones(())
print(scalar_one())
@np.use_np_shape
class ScalarTensor(object):
def __init__(self, val=None):
if val is None:
val = ScalarTensor.random().value
self._scalar = mx.nd.ones(()) * val
def __repr__(self):
print("Is __repr__ in np_shape semantics? {}!".format(str(np.is_np_shape())))
return str(self._scalar.asnumpy())
@staticmethod
def random():
val = mx.nd.random.uniform().asnumpy().item()
return ScalarTensor(val)
@property
def value(self):
print("Is value property in np_shape semantics? {}!".format(str(np.is_np_shape())))
return self._scalar.asnumpy().item()
print("Is global scope of np_shape activated? {}!".format(str(np.is_np_shape())))
scalar_tensor = ScalarTensor()
print(scalar_tensor)
Parameters
----------
func : a user-provided callable function or class to be scoped by the NumPy-shape semantics.
Returns
-------
Function or class
A function or class wrapped in the NumPy-shape scope.
"""
if inspect.isclass(func):
for name, method in inspect.getmembers(
func,
predicate=lambda f: inspect.isfunction(f) or inspect.ismethod(
f) or isinstance(f, property)):
if isinstance(method, property):
setattr(
func, name,
property(use_np_shape(method.__get__), method.__set__,
method.__delattr__, method.__doc__))
else:
setattr(func, name, use_np_shape(method))
return func
elif callable(func):
@functools.wraps(func)
def _with_np_shape(*args, **kwargs):
with np_shape(active=True):
return func(*args, **kwargs)
return _with_np_shape
else:
raise TypeError(
'use_np_shape can only decorate classes and callable objects, '
'while received a {}'.format(str(type(func))))
def _is_public_attribute(self, member):
return not ismethod(member[1]) and not isinstance(
member[1], Model) and member[0][0] != "_"
def invoke(self, model, prefix_args=None, varargs=False):
'''
Invoke a callable `model` as if it was a native function. If `varargs`
is true, model receives a single argument that is a generator for
function arguments. Pass a tuple of arguments for `prefix_args` you'd
like to precede the actual arguments.
:param callable model: Python model of the function
:param tuple prefix_args: Parameters to pass to model before actual ones
:param bool varargs: Whether the function expects a variable number of arguments
:return: The result of calling `model`
'''
prefix_args = prefix_args or ()
spec = inspect.getargspec(model)
if spec.varargs:
logger.warning("ABI: A vararg model must be a unary function.")
nargs = len(spec.args) - len(prefix_args)
# If the model is a method, we need to account for `self`
if inspect.ismethod(model):
nargs -= 1
def resolve_argument(arg):
if isinstance(arg, str):
return self._cpu.read_register(arg)
else:
return self._cpu.read_int(arg)
# Create a stream of resolved arguments from argument descriptors
descriptors = self.get_arguments()
argument_iter = imap(resolve_argument, descriptors)
try:
if varargs:
result = model(*(prefix_args + (argument_iter, )))
else:
argument_tuple = prefix_args + tuple(
islice(argument_iter, nargs))
result = model(*argument_tuple)
except ConcretizeArgument as e:
assert e.argnum >= len(
prefix_args), "Can't concretize a constant arg"
idx = e.argnum - len(prefix_args)
# Arguments were lazily computed in case of varargs, so recompute here
descriptors = self.get_arguments()
src = next(islice(descriptors, idx, idx + 1))
msg = 'Concretizing due to model invocation'
if isinstance(src, str):
raise ConcretizeRegister(src, msg)
else:
raise ConcretizeMemory(src, self._cpu.address_bit_size, msg)
else:
if result is not None:
self.write_result(result)
self.ret()
return result
def is_user_method(m):
return ((inspect.ismethod(m) or inspect.isfunction(m))
and not inspect.isbuiltin(m)
and not ClientProxyBuilder._method_name(m).startswith('__')
and not ClientProxyBuilder._method_name(m).endswith('__'))
def as_stub_func_if_any(func0,
decorated_func=None,
func_class=None,
nesting=None):
# Check for stubfile
# Todo: Compactify
module = get_stub_module(func0)
if not module is None:
if hasattr(module, func0.__name__):
res = getattr(module, func0.__name__)
if inspect.isfunction(res) or inspect.ismethod(res) \
or inspect.ismethoddescriptor(res):
return getattr(module, func0.__name__)
if not decorated_func is None and ismethod(decorated_func):
cls = util.get_class_that_defined_method(decorated_func)
if hasattr(module, cls.__name__):
cls2 = getattr(module, cls.__name__)
if hasattr(cls2, func0.__name__):
return getattr(cls2, func0.__name__)
else:
if nesting is None:
nesting = util._get_class_nesting_list(
cls, sys.modules[cls.__module__])
else:
nesting = nesting[:-1]
if not nesting is None:
mcls = module
try:
for cl in nesting:
mcls = getattr(mcls, cl.__name__)
mcls = getattr(mcls, cls.__name__)
return getattr(mcls, func0.__name__)
except AttributeError:
pass
elif not func_class is None:
if hasattr(module, func_class.__name__):
cls2 = getattr(module, func_class.__name__)
if hasattr(cls2, func0.__name__):
return getattr(cls2, func0.__name__)
else:
if nesting is None:
nesting = util._get_class_nesting_list(
func_class, sys.modules[func_class.__module__])
if not nesting is None:
mcls = module
try:
for cl in nesting:
mcls = getattr(mcls, cl.__name__)
mcls = getattr(mcls, func_class.__name__)
return getattr(mcls, func0.__name__)
except AttributeError:
pass
if nesting is None:
nesting = util._get_class_nesting_list_for_staticmethod(
decorated_func, sys.modules[func0.__module__], [], set())
if not nesting is None:
mcls = module
try:
for cl in nesting:
mcls = getattr(mcls, cl.__name__)
return getattr(mcls, func0.__name__)
except AttributeError:
pass
return func0
def _get_methods(cls):
import inspect
# In Python 3 unbound methods are functions, but in Python 2 they are methods
return inspect.getmembers(
cls, predicate=lambda x: inspect.isfunction(x) or inspect.ismethod(x))
def validate_class(val):
if inspect.isfunction(val) or inspect.ismethod(val):
val = val()
if inspect.isclass(val):
return val
return validate_string(val)
def is_procedure(obj):
return (
inspect.ismethod(obj) or
inspect.isfunction(obj)
)
def ismethod(self):
"""Return true if the object is a method.
"""
return inspect.ismethod(self.obj)
def is_method(func):
# Under Python 3, there are no unbound methods
return isfunction(func) or ismethod(func)
def predicate(o):
if inspect.ismethod(o):
return hasattr(o, "__route_method__") and hasattr(
o, "__route_path__")
return False
def findmethods(object):
return inspect.ismethod(object) or inspect.isfunction(object)
def _add_locals_data(data, exc_info):
if not SETTINGS['locals']['enabled']:
return
frames = data['body']['trace']['frames']
cur_tb = exc_info[2]
frame_num = 0
num_frames = len(frames)
while cur_tb:
cur_frame = frames[frame_num]
tb_frame = cur_tb.tb_frame
cur_tb = cur_tb.tb_next
if not isinstance(tb_frame, types.FrameType):
# this can happen if the traceback or frame is wrapped in some way,
# for example by `ExceptionInfo` in
# https://github.com/celery/billiard/blob/master/billiard/einfo.py
log.warning('Traceback frame not a types.FrameType. Ignoring.')
frame_num += 1
continue
# Create placeholders for args/kwargs/locals
args = []
kw = {}
_locals = {}
try:
arginfo = inspect.getargvalues(tb_frame)
local_vars = arginfo.locals
argspec = None
func = _get_func_from_frame(tb_frame)
if func:
if inspect.isfunction(func) or inspect.ismethod(func):
argspec = inspect.getargspec(func)
elif inspect.isclass(func):
init_func = getattr(func, '__init__', None)
if init_func:
argspec = inspect.getargspec(init_func)
# Fill in all of the named args
for named_arg in arginfo.args:
args.append(_local_repr(local_vars[named_arg]))
# Add any varargs
if arginfo.varargs is not None:
args.extend(map(_local_repr, local_vars[arginfo.varargs]))
# Fill in all of the kwargs
if arginfo.keywords is not None:
kw.update(
dict((k, _local_repr(v))
for k, v in local_vars[arginfo.keywords].items()))
if argspec and argspec.defaults:
# Put any of the args that have defaults into kwargs
num_defaults = len(argspec.defaults)
if num_defaults:
# The last len(argspec.defaults) args in arginfo.args should be added
# to kwargs and removed from args
kw.update(
dict(
zip(arginfo.args[-num_defaults:],
args[-num_defaults:])))
args = args[:-num_defaults]
# Optionally fill in locals for this frame
if local_vars and _check_add_locals(cur_frame, frame_num,
num_frames):
_locals.update(
dict((k, _local_repr(v)) for k, v in local_vars.items()))
args = _scrub_obj(args)
kw = _scrub_obj(kw)
_locals = _scrub_obj(_locals)
except Exception as e:
log.exception(
'Error while extracting arguments from frame. Ignoring.')
if args:
cur_frame['args'] = args
if kw:
cur_frame['kwargs'] = kw
if _locals:
cur_frame['locals'] = _locals
frame_num += 1
def getAllMethod(self, module_str):
module = __import__(module_str, fromlist=[''])
method_list = [
o for o in inspect.getmembers(module) if inspect.ismethod(o[1])
]
return method_list
def outer(new_func):
def wrapper(*args, **kwargs):
return new_func(orig_func, *args, **kwargs)
if inspect.ismethod(orig_func):
setattr(orig_func.im_class, orig_func.__name__, wrapper)
return wrapper
def wrapper(wrapped, instance, args, kwargs):
transaction = current_transaction()
if transaction is None:
return wrapped(*args, **kwargs)
if callable(name):
if instance and inspect.ismethod(wrapped):
_name = name(instance, *args, **kwargs)
else:
_name = name(*args, **kwargs)
elif name is None:
_name = callable_name(wrapped)
else:
_name = name
if callable(group):
if instance and inspect.ismethod(wrapped):
_group = group(instance, *args, **kwargs)
else:
_group = group(*args, **kwargs)
else:
_group = group
if callable(label):
if instance and inspect.ismethod(wrapped):
_label = label(instance, *args, **kwargs)
else:
_label = label(*args, **kwargs)
else:
_label = label
if callable(params):
if instance and inspect.ismethod(wrapped):
_params = params(instance, *args, **kwargs)
else:
_params = params(*args, **kwargs)
else:
_params = params
def _generator(generator):
_gname = '%s (generator)' % _name
try:
value = None
exc = None
while True:
transaction = current_transaction()
params = {}
frame = generator.gi_frame
params['filename'] = frame.f_code.co_filename
params['lineno'] = frame.f_lineno
with FunctionTrace(transaction,
_gname,
_group,
params=params):
try:
if exc is not None:
yielded = generator.throw(*exc)
exc = None
else:
yielded = generator.send(value)
except StopIteration:
raise
except Exception:
raise
try:
value = yield yielded
except Exception:
exc = sys.exc_info()
finally:
generator.close()
with FunctionTrace(transaction, _name, _group, _label, _params):
try:
result = wrapped(*args, **kwargs)
except Exception:
raise
else:
if isinstance(result, types.GeneratorType):
return _generator(result)
else:
return result
def create(cls,
func,
args=None,
kwargs=None,
connection=None,
result_ttl=None,
ttl=None,
status=None,
description=None,
depends_on=None,
timeout=None,
id=None,
origin=None,
meta=None,
failure_ttl=None,
serializer=None):
"""Creates a new Job instance for the given function, arguments, and
keyword arguments.
"""
if args is None:
args = ()
if kwargs is None:
kwargs = {}
if not isinstance(args, (tuple, list)):
raise TypeError('{0!r} is not a valid args list'.format(args))
if not isinstance(kwargs, dict):
raise TypeError('{0!r} is not a valid kwargs dict'.format(kwargs))
job = cls(connection=connection, serializer=serializer)
if id is not None:
job.set_id(id)
if origin is not None:
job.origin = origin
# Set the core job tuple properties
job._instance = None
if inspect.ismethod(func):
job._instance = func.__self__
job._func_name = func.__name__
elif inspect.isfunction(func) or inspect.isbuiltin(func):
job._func_name = '{0}.{1}'.format(func.__module__, func.__name__)
elif isinstance(func, string_types):
job._func_name = as_text(func)
elif not inspect.isclass(func) and hasattr(
func, '__call__'): # a callable class instance
job._instance = func
job._func_name = '__call__'
else:
raise TypeError(
'Expected a callable or a string, but got: {0}'.format(func))
job._args = args
job._kwargs = kwargs
# Extra meta data
job.description = description or job.get_call_string()
job.result_ttl = parse_timeout(result_ttl)
job.failure_ttl = parse_timeout(failure_ttl)
job.ttl = parse_timeout(ttl)
job.timeout = parse_timeout(timeout)
job._status = status
job.meta = meta or {}
# dependency could be job instance or id
if depends_on is not None:
job._dependency_ids = [
depends_on.id if isinstance(depends_on, Job) else depends_on
]
return job
def isTest(attr):
return inspect.ismethod(attr) and "EdscTest.setUp " not in str(attr)
def main():
p = optparse.OptionParser(__doc__.strip())
p.add_option("-p",
"--phantom",
action="store",
type="string",
dest="phantom",
default=None,
help="Phantom import modules from a file")
p.add_option(
"-o",
"--output-dir",
action="store",
type="string",
dest="output_dir",
default=None,
help=("Write all output files to the given directory (instead "
"of writing them as specified in the autosummary:: "
"directives)"))
options, args = p.parse_args()
if len(args) == 0:
p.error("wrong number of arguments")
if options.phantom and os.path.isfile(options.phantom):
import_phantom_module(options.phantom)
# read
names = {}
for name, loc in get_documented(args).items():
for (filename, sec_title, keyword, toctree) in loc:
if toctree is not None:
path = os.path.join(os.path.dirname(filename), toctree)
names[name] = os.path.abspath(path)
# write
for name, path in sorted(names.items()):
if options.output_dir is not None:
path = options.output_dir
if not os.path.isdir(path):
os.makedirs(path)
try:
obj, name = import_by_name(name)
except ImportError, e:
print "Failed to import '%s': %s" % (name, e)
continue
fn = os.path.join(path, '%s.rst' % name)
if os.path.exists(fn):
# skip
continue
f = open(fn, 'w')
try:
f.write('%s\n%s\n\n' % (name, '=' * len(name)))
if inspect.isclass(obj):
if issubclass(obj, Exception):
f.write(format_modulemember(name, 'autoexception'))
else:
f.write(format_modulemember(name, 'autoclass'))
elif inspect.ismodule(obj):
f.write(format_modulemember(name, 'automodule'))
elif inspect.ismethod(obj) or inspect.ismethoddescriptor(obj):
f.write(format_classmember(name, 'automethod'))
elif callable(obj):
f.write(format_modulemember(name, 'autofunction'))
elif hasattr(obj, '__get__'):
f.write(format_classmember(name, 'autoattribute'))
else:
f.write(format_modulemember(name, 'autofunction'))
finally:
f.close()
def pred(x):
return (inspect.isfunction(x) or inspect.ismethod(x)
or is_cython(x))
def pyhelp(s, imports=None):
"""Return object description"""
_import_modules(imports, globals(), None)
return _getdoc(s)
def pysignature(s):
"""Return info about function parameters"""
f = None
try:
f = eval(s)
except Exception, ex:
return "%s" % ex
if inspect.ismethod(f):
f = f.im_func
if not inspect.isfunction(f):
return ''
(args, varargs, varkw, defaults) = inspect.getargspec(f)
return (
'%s: %s' %
(f.__name__, inspect.formatargspec(args, varargs, varkw, defaults)))
def _getdoc(s):
"""Return string printed by `help` function"""
obj = None
try:
obj = eval(s)
except Exception, ex:
def get_items(cls):
""" get key/value items from an enum-like class (members represent enumeration key/value) """
res = {k: v for k, v in getmembers(cls) if not (k.startswith("_") or ismethod(v))}
return res
def build_py_coverage(self):
objects = self.env.domaindata['py']['objects']
modules = self.env.domaindata['py']['modules']
skip_undoc = self.config.coverage_skip_undoc_in_source
for mod_name in modules:
ignore = False
for exp in self.mod_ignorexps:
if exp.match(mod_name):
ignore = True
break
if ignore:
continue
try:
mod = __import__(mod_name, fromlist=['foo'])
except ImportError as err:
self.warn('module %s could not be imported: %s' %
(mod_name, err))
self.py_undoc[mod_name] = {'error': err}
continue
funcs = []
classes = {}
for name, obj in inspect.getmembers(mod):
# diverse module attributes are ignored:
if name[0] == '_':
# begins in an underscore
continue
if not hasattr(obj, '__module__'):
# cannot be attributed to a module
continue
if obj.__module__ != mod_name:
# is not defined in this module
continue
full_name = '%s.%s' % (mod_name, name)
if inspect.isfunction(obj):
if full_name not in objects:
for exp in self.fun_ignorexps:
if exp.match(name):
break
else:
if skip_undoc and not obj.__doc__:
continue
funcs.append(name)
elif inspect.isclass(obj):
for exp in self.cls_ignorexps:
if exp.match(name):
break
else:
if full_name not in objects:
if skip_undoc and not obj.__doc__:
continue
# not documented at all
classes[name] = []
continue
attrs = []
for attr_name in dir(obj):
if attr_name not in obj.__dict__:
continue
attr = getattr(obj, attr_name)
if not (inspect.ismethod(attr)
or inspect.isfunction(attr)):
continue
if attr_name[0] == '_':
# starts with an underscore, ignore it
continue
if skip_undoc and not attr.__doc__:
# skip methods without docstring if wished
continue
full_attr_name = '%s.%s' % (full_name, attr_name)
if full_attr_name not in objects:
attrs.append(attr_name)
if attrs:
# some attributes are undocumented
classes[name] = attrs
self.py_undoc[mod_name] = {'funcs': funcs, 'classes': classes}
def SUBRP(x):
return inspect.isbuiltin(x) or inspect.isfunction(x) or inspect.ismethod(
x) or inspect.isclass(x)
