def file_build(self, path, modname=None):
"""Build astroid from a source code file (i.e. from an ast)
*path* is expected to be a python source file
"""
try:
stream, encoding, data = open_source_file(path)
except IOError as exc:
raise exceptions.AstroidBuildingError(
'Unable to load file {path}:\n{error}',
modname=modname,
path=path,
error=exc) from exc
except (SyntaxError, LookupError) as exc:
raise exceptions.AstroidSyntaxError(
'Python 3 encoding specification error or unknown encoding:\n'
'{error}',
modname=modname,
path=path,
error=exc) from exc
except UnicodeError as exc: # wrong encoding
# detect_encoding returns utf-8 if no encoding specified
raise exceptions.AstroidBuildingError(
'Wrong or no encoding specified for {filename}.',
filename=path) from exc
with stream:
# get module name if necessary
if modname is None:
try:
modname = '.'.join(modutils.modpath_from_file(path))
except ImportError:
modname = os.path.splitext(os.path.basename(path))[0]
# build astroid representation
module = self._data_build(data, modname, path)
return self._post_build(module, encoding)
def infer_ast_from_something(self, obj, context=None):
"""infer astroid for the given class"""
if hasattr(obj, '__class__') and not isinstance(obj, type):
klass = obj.__class__
else:
klass = obj
try:
modname = klass.__module__
except AttributeError as exc:
raise exceptions.AstroidBuildingError(
'Unable to get module for {class_repr}.',
cls=klass, class_repr=safe_repr(klass)) from exc
except Exception as exc:
raise exceptions.AstroidImportError(
'Unexpected error while retrieving module for {class_repr}:\n'
'{error}', cls=klass, class_repr=safe_repr(klass)) from exc
try:
name = klass.__name__
except AttributeError as exc:
raise exceptions.AstroidBuildingError(
'Unable to get name for {class_repr}:\n',
cls=klass, class_repr=safe_repr(klass)) from exc
except Exception as exc:
raise exceptions.AstroidImportError(
'Unexpected error while retrieving name for {class_repr}:\n'
'{error}', cls=klass, class_repr=safe_repr(klass)) from exc
# take care, on living object __module__ is regularly wrong :(
modastroid = self.ast_from_module_name(modname)
if klass is obj:
for inferred in modastroid.igetattr(name, context):
yield inferred
else:
for inferred in modastroid.igetattr(name, context):
yield inferred.instantiate_class()
def ast_from_file(self,
filepath,
modname=None,
fallback=True,
source=False):
"""given a module name, return the astroid object"""
try:
filepath = modutils.get_source_file(filepath, include_no_ext=True)
source = True
except modutils.NoSourceFile:
pass
if modname is None:
try:
modname = ".".join(modutils.modpath_from_file(filepath))
except ImportError:
modname = filepath
if (modname in self.astroid_cache
and self.astroid_cache[modname].file == filepath):
return self.astroid_cache[modname]
if source:
# pylint: disable=import-outside-toplevel; circular import
from astroid.builder import AstroidBuilder
return AstroidBuilder(self).file_build(filepath, modname)
if fallback and modname:
return self.ast_from_module_name(modname)
raise exceptions.AstroidBuildingError(
"Unable to build an AST for {path}.", path=filepath)
def ast_from_class(self, klass, modname=None):
"""get astroid for the given class"""
if modname is None:
try:
modname = klass.__module__
except AttributeError as exc:
raise exceptions.AstroidBuildingError(
'Unable to get module for class {class_name}.',
cls=klass, class_repr=safe_repr(klass), modname=modname) from exc
modastroid = self.ast_from_module_name(modname)
return modastroid.getattr(klass.__name__)[0] # XXX
def hook(modname):
if modname == 'foo.bar':
return unittest
else:
raise exceptions.AstroidBuildingError()
def hook(modname):
if modname == "foo.bar":
return unittest
raise exceptions.AstroidBuildingError()
