def _get_imports(self) -> List[ast.stmt]:
return [
ast.ImportFrom(
module='__future__',
names=[ast.alias(name='absolute_import', asname=None)],
level=0),
ast.ImportFrom(module='__future__',
names=[ast.alias(name='division', asname=None)],
level=0),
ast.ImportFrom(
module='__future__',
names=[ast.alias(name='print_function', asname=None)],
level=0)
]
def _split_imports(body):
"""Given a body reurn the import statemens and remaining statements."""
imports = []
remainder = []
stdimports = []
in_imports = True
for line in body:
if in_imports:
if isinstance(line, ast3.Import):
for alias in line.names:
if alias.name in constants.STANDARD_PYTHON_MODULES:
stdimports.append(ast3.Import(names=[alias]))
else:
imports.append(ast3.Import(names=[alias]))
elif isinstance(line, ast3.ImportFrom):
new_imports = [
ast3.ImportFrom(
module=line.module,
names=[name],
) for name in line.names
]
if line.module in constants.STANDARD_PYTHON_MODULES:
stdimports += new_imports
else:
imports += new_imports
else:
in_imports = False
if not in_imports:
remainder.append(line)
return stdimports, imports, remainder
def ensure_mpi(self, canonical_name, alias):
# if ('mpi4py', None) not in self._import_statements:
self._import_statements[canonical_name, alias] = [
typed_ast3.ImportFrom(
module='mpi4py',
names=[typed_ast3.alias(name='MPI', asname=None)],
level=0),
# typed_ast3.parse('mpi4py.config = no_auto_init', mode='eval') # TODO: may be needed
]
def visit_ImportFrom(self,
node: ast3.ImportFrom) -> Iterable[ast3.ImportFrom]:
parent_module_path = to_parent_module_path(
node, parent_module_path=self.module_path)
for name_alias in node.names:
actual_path = to_actual_path(name_alias)
if actual_path == catalog.WILDCARD_IMPORT:
yield from to_flat_root(parent_module_path).body
else:
yield ast3.ImportFrom(str(parent_module_path), [name_alias], 0)
def _replace_import_from_module(self, node: ast.ImportFrom, from_: str,
to: str) -> ast.Try:
"""Replaces import from with try/except with old and new import module."""
self._tree_changed = True
rewrote_module = node.module.replace(from_, to, 1)
rewrote = ast.ImportFrom(module=rewrote_module,
names=node.names,
level=node.level)
return self.wrapper.get_body(
previous=node, # type: ignore
current=rewrote)[0]
def _get_replaced_import_from_part(
self, node: ast.ImportFrom, alias: ast.alias,
names_to_replace: Dict[str, Tuple[str, str]]) -> ast.ImportFrom:
"""Returns import from statement with changed module or alias."""
full_name = '{}.{}'.format(node.module, alias.name)
if full_name in names_to_replace:
full_name = full_name.replace(names_to_replace[full_name][0],
names_to_replace[full_name][1], 1)
module_name = '.'.join(full_name.split('.')[:-1])
name = full_name.split('.')[-1]
return ast.ImportFrom(
module=module_name,
names=[ast.alias(name=name, asname=alias.asname or alias.name)],
level=node.level)
def test_ast_validator_synthetic(self):
examples = ((typed_ast3,
typed_ast3.FormattedValue(typed_ast3.Str('value'), None,
None)),
(typed_ast3,
typed_ast3.keyword(
None, typed_ast3.Name('value', typed_ast3.Load()))),
(typed_ast3,
typed_ast3.ImportFrom('pkg',
[typed_ast3.alias('module', None)],
None)))
for fields_first, (ast_module, example) in itertools.product(
(False, True), examples):
with self.subTest(example=example):
# tree = ast_module.Expression(example)
validator = AstValidator[ast_module](fields_first=fields_first,
mode=None)
validator.visit(example)
def visit_ImportFrom(self, node: ast3.ImportFrom) -> VisitorOutput:
"""Defines how to import (from) modules (supported and nonsupported)
For example, it converts::
from numpy import array
from numpy import *
from somelib import var, othervar as var2
from otherlib import *
into::
from pytropos.libs_checking import numpy_module
st['array'] = numpy_module.attr['array', pos...]
from pytropos.libs_checking import numpy_module
st.importStar(numpy_module)
st['var'] = pt.Top
st['var2'] = pt.Top
st.importStar()
"""
libs: 'List[ast3.AST]' = []
if node.module in self._supported_modules:
module_name = self._supported_modules[node.module]
# from pytropos.libs_checking import module_name
libs.append(
ast3.ImportFrom(
module='pytropos.libs_checking',
names=[ast3.alias(name=module_name, asname=None)],
level=0,
))
if node.names[0].name == '*':
# st.importStar(module_name)
libs.append(
ast3.Expr(value=ast3.Call(
func=ast3.Attribute(
value=ast3.Name(id='st', ctx=ast3.Load()),
attr='importStar',
ctx=ast3.Load(),
),
args=[ast3.Name(id=module_name, ctx=ast3.Load())],
keywords=[],
), ))
else:
for alias in node.names:
# st['asname'] = modname.attr['name']
pos = pos_as_tuple(node)
if pos is not None:
attrname = ast3.Tuple(
elts=[ast3.Str(s=alias.name), pos],
ctx=ast3.Load()) # type: ast3.expr
else:
attrname = ast3.Str(s=alias.name)
libs.append(
ast3.Assign(
targets=[
ast3.Subscript(
value=ast3.Name(id='st', ctx=ast3.Load()),
slice=ast3.Index(value=ast3.Str(
s=alias.asname if alias.
asname else alias.name), ),
ctx=ast3.Store(),
),
],
value=ast3.Subscript(
value=ast3.Attribute(
value=ast3.Name(id=module_name,
ctx=ast3.Load()),
attr='attr',
ctx=ast3.Load(),
),
slice=ast3.Index(value=attrname, ),
ctx=ast3.Load(),
),
))
else:
if node.names[0].name == '*':
# st.importStar()
libs.append(
ast3.Expr(value=ast3.Call(
func=ast3.Attribute(
value=ast3.Name(id='st', ctx=ast3.Load()),
attr='importStar',
ctx=ast3.Load(),
),
args=[],
keywords=[],
), ))
else:
libs.extend(
ast3.parse( # type: ignore
'\n'.join([
"st['{asname}'] = pt.Top".format(
asname=alias.asname if alias.asname else alias.
name) for alias in node.names
])).body)
return libs
def visit_Import(self, node: ast3.Import) -> VisitorOutput:
"""Defines how to import modules (supported and nonsupported)
For example, it converts::
import numpy
import numpy as np
import somelib, otherlib as other
into::
from pytropos.libs_checking import numpy_module
st['numpy'] = numpy_module
from pytropos.libs_checking import numpy_module
st['np'] = numpy_module
st['somelib'] = pt.ModuleTop
st['other'] = pt.ModuleTop
"""
# Checking if the library being loaded is supported by pytropos
non_supported_modules: 'List[str]' = []
modules_supported: 'List[Tuple[str, Optional[str]]]' = []
for alias in node.names:
if alias.name in self._supported_modules:
modules_supported.append(
(alias.name, alias.asname)) # noqa: E201,E202
else:
non_supported_modules.append(
alias.name if alias.asname is None else alias.asname)
# Loading fake modules from pytropos (if supported)
libs: 'List[ast3.AST]' = []
if len(modules_supported) > 0:
libs.append(
ast3.ImportFrom(
module='pytropos.libs_checking',
names=[
ast3.alias(name=self._supported_modules[name],
asname=None)
for [name, asname] in modules_supported
],
level=0,
))
libs.extend(
ast3.parse( # type: ignore
'\n'.join([
f"st['{asname}'] = {self._supported_modules[name]}"
for name, asname in modules_supported
])).body)
# Loading modules as Any (if not supported)
if non_supported_modules:
libs.extend(
ast3.parse( # type: ignore
'\n'.join([
f"st['{name}'] = pt.ModuleTop"
for name in non_supported_modules
])).body)
return libs
