def function_to_graph(f, conversion_map, arg_values, arg_types, owner_type=None): """Specialization of `entity_to_graph` for callable functions.""" node, source = parser.parse_entity(f) node = node.body[0] namespace = inspect_utils.getnamespace(f) _add_self_references(namespace, conversion_map.api_module) namer = conversion_map.new_namer(namespace) ctx = context.EntityContext( namer=namer, source_code=source, source_file='<fragment>', namespace=namespace, arg_values=arg_values, arg_types=arg_types, owner_type=owner_type, recursive=conversion_map.recursive) node, deps = node_to_graph(node, ctx, conversion_map.nocompile_decorators) # TODO(mdan): This somewhat duplicates the call rename logic in call_treest.py new_name, did_rename = namer.compiled_function_name(f.__name__, f, owner_type) if not did_rename: new_name = f.__name__ if node.name != f.__name__: raise NotImplementedError('Strange corner case. Send us offending code!') node.name = new_name conversion_map.update_name_map(namer) # TODO(mdan): Use this at compilation. conversion_map.additional_imports.update(deps) return node, new_name
def function_to_graph(f, conversion_map, arg_values, arg_types, owner_type=None): """Specialization of `entity_to_graph` for callable functions.""" node = parser.parse_object(f).body[0] namespace = six.get_function_globals(f) # This is needed for non-global functions. closure = six.get_function_closure(f) if closure: for e in closure: if callable(e.cell_contents): fn = e.cell_contents namespace[fn.__name__] = fn namer = conversion_map.new_namer(namespace) ctx = context.EntityContext( namer=namer, source_code=tf_inspect.getsource(f), source_file=tf_inspect.getfile(f), namespace=namespace, arg_values=arg_values, arg_types=arg_types) node = node_to_graph(node, ctx, conversion_map.nocompile_decorators) # Simulate a rename to ensure the top level is in the name map. This is needed # for top level functions, and it also helps the consistency verification made # by update_name_map. if owner_type is not None: new_name = namer.compiled_function_name(f.__name__, f, owner_type) else: new_name = namer.compiled_function_name(f.__name__, f) node.name = new_name conversion_map.update_name_map(namer) return node, conversion_map.name_map[f]
def parse_and_analyze(self, test_fn, namespace, namer=None, arg_types=None, include_type_analysis=True, owner_type=None, recursive=True): node, source = parser.parse_entity(test_fn) ctx = context.EntityContext( namer=namer or FakeNamer(), source_code=source, source_file=None, namespace=namespace, arg_values=None, arg_types=arg_types, owner_type=owner_type, recursive=recursive, type_annotation_func=utils.set_element_type) node = qual_names.resolve(node) node = activity.resolve(node, ctx) node = live_values.resolve(node, ctx, {}) if include_type_analysis: node = type_info.resolve(node, ctx) node = live_values.resolve(node, ctx, {}) self.ctx = ctx return node
def _parse_and_analyze(self, test_fn): node, source = parser.parse_entity(test_fn) ctx = context.EntityContext(namer=None, source_code=source, source_file=None, namespace={}, arg_values=None, arg_types=None, recursive=True) node = access.resolve(node, ctx) return node
def _parse_and_analyze(self, test_fn, namespace, arg_types=None): ctx = context.EntityContext(namer=None, source_code=None, source_file=None, namespace=namespace, arg_values=None, arg_types=arg_types) node = parser.parse_object(test_fn) node = access.resolve(node) node = live_values.resolve(node, namespace, {}) node = type_info.resolve(node, ctx) return node
def _parse_and_analyze(self, test_fn, namespace, arg_types=None): node, source = parser.parse_entity(test_fn) ctx = context.EntityContext(namer=None, source_code=source, source_file=None, namespace=namespace, arg_values=None, arg_types=arg_types, recursive=True) node = qual_names.resolve(node) node = activity.resolve(node, ctx) node = live_values.resolve(node, ctx, {}) node = type_info.resolve(node, ctx) node = live_values.resolve(node, ctx, {}) return node
def function_to_graph(f, conversion_map, arg_values, arg_types, owner_type=None): """Specialization of `entity_to_graph` for callable functions.""" node, source = parser.parse_entity(f) node = node.body[0] namespace = six.get_function_globals(f) # This is needed for non-global functions. closure = six.get_function_closure(f) if closure: for e in closure: if callable(e.cell_contents): fn = e.cell_contents namespace[fn.__name__] = fn # Manually add the utils namespace which may be used from generated code. if 'py2tf_util' not in namespace: namespace['py2tf_utils'] = utils elif namespace['py2tf_utils'] != utils: raise ValueError( 'The module name py2tf_utils is reserved and may not be used.') namer = conversion_map.new_namer(namespace) ctx = context.EntityContext(namer=namer, source_code=source, source_file='<fragment>', namespace=namespace, arg_values=arg_values, arg_types=arg_types, recursive=conversion_map.recursive) node = node_to_graph(node, ctx, conversion_map.nocompile_decorators) # TODO(mdan): This somewhat duplicates the call rename logic in call_treest.py new_name, did_rename = namer.compiled_function_name( f.__name__, f, owner_type) if not did_rename: new_name = f.__name__ if node.name != f.__name__: raise NotImplementedError( 'Strange corner case. Send us offending code!') node.name = new_name conversion_map.update_name_map(namer) return node, new_name
def _parse_and_analyze(self, test_fn, namespace, literals=None, arg_types=None): literals = literals or {} arg_types = arg_types or {} node, source = parser.parse_entity(test_fn) ctx = context.EntityContext(namer=None, source_code=source, source_file=None, namespace=namespace, arg_values=None, arg_types=arg_types, recursive=True) node = access.resolve(node, ctx) node = live_values.resolve(node, ctx, literals) node = type_info.resolve(node, ctx) node = live_values.resolve(node, ctx, literals) return node
def parse_and_analyze(self, test_fn, namespace, namer=None, arg_types=None, include_type_analysis=True, recursive=True): node, source = parser.parse_entity(test_fn) ctx = context.EntityContext(namer=namer, source_code=source, source_file=None, namespace=namespace, arg_values=None, arg_types=arg_types, recursive=recursive) node = access.resolve(node, ctx) node = live_values.resolve(node, ctx, {}) if include_type_analysis: node = type_info.resolve(node, ctx) node = live_values.resolve(node, ctx, {}) self.ctx = ctx return node