def _lines_for_comp()

in tensorflow_federated/python/core/impl/compiler/building_blocks.py [0:0]

• 60 lines of code
• 18 McCabe index (conditional complexity)

  def _lines_for_comp(comp, formatted):
    """Returns a `list` of strings representing the given `comp`.

    Args:
      comp: An instance of a `ComputationBuildingBlock`.
      formatted: A boolean indicating if the returned string should be
        formatted.
    """
    if comp.is_block():
      lines = []
      variables_lines = _lines_for_named_comps(comp.locals, formatted)
      if formatted:
        variables_lines = _indent(variables_lines)
        lines.extend([['(let ', ''], variables_lines, ['', ' in ']])
      else:
        lines.extend([['(let '], variables_lines, [' in ']])
      result_lines = _lines_for_comp(comp.result, formatted)
      lines.append(result_lines)
      lines.append([')'])
      return _join(lines)
    elif comp.is_reference():
      if comp.context is not None:
        return ['{}@{}'.format(comp.name, comp.context)]
      else:
        return [comp.name]
    elif comp.is_selection():
      source_lines = _lines_for_comp(comp.source, formatted)
      if comp.name is not None:
        return _join([source_lines, ['.{}'.format(comp.name)]])
      else:
        return _join([source_lines, ['[{}]'.format(comp.index)]])
    elif comp.is_call():
      function_lines = _lines_for_comp(comp.function, formatted)
      if comp.argument is not None:
        argument_lines = _lines_for_comp(comp.argument, formatted)
        return _join([function_lines, ['('], argument_lines, [')']])
      else:
        return _join([function_lines, ['()']])
    elif comp.is_compiled_computation():
      return ['comp#{}'.format(comp.name)]
    elif comp.is_data():
      return [comp.uri]
    elif comp.is_intrinsic():
      return [comp.uri]
    elif comp.is_lambda():
      result_lines = _lines_for_comp(comp.result, formatted)
      if comp.parameter_type is None:
        param_name = ''
      else:
        param_name = comp.parameter_name
      lines = [['({} -> '.format(param_name)], result_lines, [')']]
      return _join(lines)
    elif comp.is_placement():
      return [comp._literal.name]  # pylint: disable=protected-access
    elif comp.is_struct():
      if len(comp) == 0:  # pylint: disable=g-explicit-length-test
        return ['<>']
      elements = structure.to_elements(comp)
      elements_lines = _lines_for_named_comps(elements, formatted)
      if formatted:
        elements_lines = _indent(elements_lines)
        lines = [['<', ''], elements_lines, ['', '>']]
      else:
        lines = [['<'], elements_lines, ['>']]
      return _join(lines)
    else:
      raise NotImplementedError('Unexpected type found: {}.'.format(type(comp)))