Prints the result "Returned Data: \n%s" % (call.result)of an API call
486695
def post_transport_log(self, call):
        """"""
        output = "Returned Data: \n{}".format(call.result)
        LOGGER.debug(output)
654716
def _generate_result(self, callname, result):
        """"""
        # Retrieve path from API class
        schema = self.api.result_schema()
        schema.context['callname'] = callname
        self.callback(schema.load(result), self.context)
363358
def call(self, operation, data):
        """"""
        print('API call [{0}:{1}], method - {2}, data - {3}'.format(
            self.host, self.api_key, operation, repr(data)))
716022
def maybe_print_as_json(opts, data, page_info=None):
    """"""
    if opts.output not in ("json", "pretty_json"):
        return False

    root = {"data": data}

    if page_info is not None and page_info.is_valid:
        meta = root["meta"] = {}
        meta["pagination"] = page_info.as_dict(num_results=len(data))

    if opts.output == "pretty_json":
        dump = json.dumps(root, indent=4, sort_keys=True)
    else:
        dump = json.dumps(root, sort_keys=True)

    click.echo(dump)
    return True
892078
def print_object_results(obj_result):
    
    print_results_header(obj_result.object_id, obj_result.is_valid)

    if obj_result.warnings:
        print_warning_results(obj_result, 1)
    if obj_result.errors:
        print_schema_results(obj_result, 1)
702119
def print
      return unless $stdout.tty?
      return if recently_fetched?

      resp = fetch_server_message
      update_fetched
      puts resp unless resp.empty?
    end
517094
def print_results(self, results, min_ratio=None, indent=False, pval=0.05, prt=sys.stdout):
        """"""
        results_adj = self.get_adj_records(results, min_ratio, pval)
        self.print_results_adj(results_adj, indent, prt)
283541
def output_results(cls, sprites):
        
        print(' '.join(cls.ATTRIBUTES))
        format_strs = ['{{{}!s:^{}}}'.format(x, len(x)) for x in
                       cls.ATTRIBUTES]
        print(' '.join(format_strs).format(**cls.attribute_result(sprites)))
880279
def printOut(value, end='\n'):
    
    sys.stdout.write(value)
    sys.stdout.write(end)
    sys.stdout.flush()
62547
function Output() {
  var body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';

  _classCallCheck(this, Output);

  this.body = body;
  this.temp = null;
}
1065988
def print(self, *args, **kwargs):
        
        print(self, *args, **kwargs)
        self.data = ''
        return self
344457
def format_return_text(self, data, function, **kwargs):  # pylint: disable=unused-argument
        '''
        
        '''
        # emulate the yaml_out output formatter. It relies on a global __opts__ object which
        # we can't obviously pass in
        try:
            try:
                outputter = data[next(iter(data))].get('out')
            except (StopIteration, AttributeError):
                outputter = None
            return salt.output.string_format(
                {x: y['return'] for x, y in six.iteritems(data)},
                out=outputter,
                opts=__opts__,
            )
        except Exception as exc:
            import pprint
            log.exception(
                'Exception encountered when trying to serialize %s',
                pprint.pformat(data)
            )
            return 'Got an error trying to serialze/clean up the response'
471939
def header_echo(cls, request,
                    api_key: (Ptypes.header, String('API key'))) -> [
            (200, 'Ok', String)]:
        ''''''
        log.info('Echoing header param, value is: {}'.format(api_key))
        for i in range(randint(0, MAX_LOOP_DURATION)):
            yield
        msg = 'The value sent was: {}'.format(api_key)
        Respond(200, msg)
60420
def pretty_print(self):
        
        msg = "Source: " + str(self._source) + "\n"
        msg += "Destination: " + str(self._destination) + "\n"
        inv_types = {v: k for k, v in defines.Types.items()}
        msg += "Type: " + str(inv_types[self._type]) + "\n"
        msg += "MID: " + str(self._mid) + "\n"
        if self._code is None:
            self._code = 0

        msg += "Code: " + str(defines.Codes.LIST[self._code].name) + "\n"
        msg += "Token: " + str(self._token) + "\n"
        for opt in self._options:
            msg += str(opt)
        msg += "Payload: " + "\n"
        msg += str(self._payload) + "\n"
        return msg
277096
def print_result(overview, *names):
    
    if names:
        for name in names:
            toprint = overview
            for part in name.split('/'):
                toprint = toprint[part]
            print(json.dumps(toprint, indent=4, separators=(',', ': ')))
    else:
        print(json.dumps(overview, indent=4, separators=(',', ': ')))
420972
def return_result(res, method)
      unless method == :lexer_name_for || method == :highlight || method == :css
        res = MultiJson.load(res, :symbolize_keys => true)
      end
      res = res.rstrip if res.class == String
      res
    end
989227
def printed_out(self, name):
        
        opt = self.variables().optional_namestring()
        req = self.variables().required_namestring()
        out = ''
        out += '|   |\n'
        out += '|   |---{}({}{})\n'.format(name, req, opt)
        if self.description:
            out += '|   |       {}\n'.format(self.description)
        return out