def igetattr(self, name, context=None):
"""infered getattr, need special treatment in class to handle
descriptors
"""
# set lookoup name since this is necessary to infer on import nodes for
# instance
context = copy_context(context)
context.lookupname = name
try:
for infered in _infer_stmts(self.getattr(name, context),
context,
frame=self):
# yield YES object instead of descriptors when necessary
if not isinstance(infered, Const) and isinstance(
infered, Instance):
try:
infered._proxied.getattr('__get__', context)
except NotFoundError:
yield infered
else:
yield YES
else:
yield infered
except NotFoundError:
if not name.startswith('__') and self.has_dynamic_getattr(context):
# class handle some dynamic attributes, return a YES object
yield YES
else:
raise InferenceError(name)
def igetattr(self, name, context=None):
"""infered getattr, need special treatment in class to handle
descriptors
"""
# set lookoup name since this is necessary to infer on import nodes for
# instance
context = copy_context(context)
context.lookupname = name
try:
for infered in _infer_stmts(self.getattr(name, context), context,
frame=self):
# yield YES object instead of descriptors when necessary
if not isinstance(infered, Const) and isinstance(infered, Instance):
try:
infered._proxied.getattr('__get__', context)
except NotFoundError:
yield infered
else:
yield YES
else:
yield infered
except NotFoundError:
if not name.startswith('__') and self.has_dynamic_getattr(context):
# class handle some dynamic attributes, return a YES object
yield YES
else:
raise InferenceError(name)
def infer_function(self, context=None):
"""infer on Function nodes must be take with care since it
may be called to infer one of it's argument (in which case <name>
should be given)
"""
name = context.lookupname
# no name is given, we are infering the function itself
if name is None:
yield self
return
if context.callcontext:
# reset call context/name
callcontext = context.callcontext
context = copy_context(context)
context.callcontext = None
for infered in callcontext.infer_argument(self, name, context):
yield infered
return
# Function.argnames can be None in astng (means that we don't have
# information on argnames), in which case we can't do anything more
if self.argnames is None:
yield YES
return
if not name in self.argnames:
raise InferenceError()
# first argument of instance/class method
if name == self.argnames[0]:
if self.type == 'method':
yield Instance(self.parent.frame())
return
if self.type == 'classmethod':
yield self.parent.frame()
return
mularg = self.mularg_class(name)
if mularg is not None: # */** argument, no doubt it's a Tuple or Dict
yield mularg
return
# if there is a default value, yield it. And then yield YES to reflect
# we can't guess given argument value
try:
context = copy_context(context)
for infered in self.default_value(name).infer(context):
yield infered
yield YES
except NoDefault:
yield YES
def igetattr(self, name, context=None):
"""infered getattr"""
# set lookup name since this is necessary to infer on import nodes for
# instance
context = copy_context(context)
context.lookupname = name
try:
return _infer_stmts(self.getattr(name, context), context, frame=self)
except NotFoundError:
raise InferenceError(name)
def igetattr(self, name, context=None):
"""infered getattr"""
# set lookup name since this is necessary to infer on import nodes for
# instance
context = copy_context(context)
context.lookupname = name
try:
return _infer_stmts(self.getattr(name, context), context, frame=self)
except NotFoundError:
raise InferenceError(name)
def ilookup(self, name, context=None):
"""infered lookup
return an iterator on infered values of the statements returned by
the lookup method
"""
frame, stmts = self.lookup(name)
context = copy_context(context)
context.lookupname = name
return _infer_stmts(stmts, context, frame)
def ilookup(self, name, context=None):
"""infered lookup
return an iterator on infered values of the statements returned by
the lookup method
"""
frame, stmts = self.lookup(name)
context = copy_context(context)
context.lookupname = name
return _infer_stmts(stmts, context, frame)
def infer_from(self, context=None, asname=True):
"""self resolve on From / Import nodes return the imported module/object"""
name = context.lookupname
if name is None:
raise InferenceError()
if asname:
name = self.real_name(name)
module = _imported_module_astng(self, self.modname)
try:
context = copy_context(context)
context.lookupname = name
return _infer_stmts(module.getattr(name), context)
except NotFoundError:
raise InferenceError(name)
