blob: 44ba312f5340006f8bd3059cc0ab3cb1e3511096 [file] [log] [blame]
# Copyright 2017 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Methods for converting model objects to human-readable formats."""
import abc
import data_quality
import io
import collections
import csv
import datetime
import itertools
import math
import time
import models
def _PrettySize(size):
# Arbitrarily chosen cut-off.
if abs(size) < 2000:
return '%d bytes' % size
# Always show 3 digits.
size /= 1024.0
if abs(size) < 10:
return '%.2fkb' % size
if abs(size) < 100:
return '%.1fkb' % size
if abs(size) < 1024:
return '%dkb' % size
size /= 1024.0
if abs(size) < 10:
return '%.2fmb' % size
# We shouldn't be seeing sizes > 100mb.
return '%.1fmb' % size
def _FormatPss(pss, force_sign=False):
# Shows a decimal for small numbers to make it clear that a shared symbol has
# a non-zero pss.
if abs(pss) > 10:
return str(int(pss))
near_int = abs(pss) % 1 < 0.05
if near_int and abs(pss) < 1 and pss:
return '~0'
if force_sign:
return ('%+.0f' if near_int else '%+.1f') % pss
return ('%.0f' if near_int else '%.1f') % pss
def _Divide(a, b):
return float(a) / b if b else 0
def _GetSectionSizeInfo(unsummed_sections, summed_sections, section_sizes):
sizes = [v for k, v in section_sizes.items() if k in summed_sections]
total_bytes = sum(sizes)
max_bytes = max(sizes)
maybe_significant_sections = unsummed_sections | summed_sections
def is_significant_section(name, size):
# Show all sections containing symbols, plus relocations.
# As a catch-all, also include any section that comprises > 4% of the
# largest section. Use largest section rather than total so that it still
# works out when showing a diff containing +100, -100 (total=0).
return (name in maybe_significant_sections
or name in ['.rela.dyn', '.rel.dyn']
or abs(_Divide(size, max_bytes)) > .04)
section_names = sorted(
k for k, v in section_sizes.items() if is_significant_section(k, v))
return (total_bytes, section_names)
class Histogram:
BUCKET_NAMES_FOR_SMALL_VALUES = {-1: '(-1,0)', 0: '{0}', 1: '(0,1)'}
def __init__(self):
self.data = collections.defaultdict(int)
# Input: (-8,-4], (-4,-2], (-2,-1], (-1,0), {0}, (0,1), [1,2), [2,4), [4,8).
# Output: -4, -3, -2, -1, 0, 1, 2, 3, 4.
@staticmethod
def _Bucket(v):
absv = abs(v)
if absv < 1:
return 0 if v == 0 else (-1 if v < 0 else 1)
mag = int(math.log(absv, 2.0)) + 2
return mag if v > 0 else -mag
@staticmethod
def _BucketName(k):
if abs(k) <= 1:
return Histogram.BUCKET_NAMES_FOR_SMALL_VALUES[k]
if k < 0:
return '(-{},-{}]'.format(1 << (-k - 1), 1 << (-k - 2))
return '[{},{})'.format(1 << (k - 2), 1 << (k - 1))
def Add(self, v):
self.data[self._Bucket(v)] += 1
def Generate(self):
keys = sorted(self.data.keys())
bucket_names = [self._BucketName(k) for k in keys]
bucket_values = [str(self.data[k]) for k in keys]
num_items = len(keys)
num_cols = 6
num_rows = (num_items + num_cols - 1) // num_cols # Divide and round up.
# Needed for range() to not throw due to step by 0.
if num_rows == 0:
return
# Spaces needed by items in each column, to align on ':'.
name_col_widths = []
value_col_widths = []
for i in range(0, num_items, num_rows):
name_col_widths.append(max(len(s) for s in bucket_names[i:][:num_rows]))
value_col_widths.append(max(len(s) for s in bucket_values[i:][:num_rows]))
yield 'Histogram of symbols based on PSS:'
for r in range(num_rows):
row = list(
zip(bucket_names[r::num_rows], name_col_widths,
bucket_values[r::num_rows], value_col_widths))
line = ' ' + ' '.join('{:>{}}: {:<{}}'.format(*t) for t in row)
yield line.rstrip()
class Describer:
def __init__(self):
pass
@abc.abstractmethod
def _DescribeDeltaSizeInfo(self, diff):
pass
@abc.abstractmethod
def _DescribeSizeInfo(self, size_info):
pass
@abc.abstractmethod
def _DescribeDeltaSymbolGroup(self, delta_group):
pass
@abc.abstractmethod
def _DescribeSymbolGroup(self, group):
pass
@abc.abstractmethod
def _DescribeSymbol(self, sym, single_line=False):
pass
def _DescribeIterable(self, obj):
for i, x in enumerate(obj):
yield '{}: {!r}'.format(i, x)
def GenerateLines(self, obj):
if isinstance(obj, models.DeltaSizeInfo):
return self._DescribeDeltaSizeInfo(obj)
if isinstance(obj, models.SizeInfo):
return self._DescribeSizeInfo(obj)
if isinstance(obj, models.DeltaSymbolGroup):
return self._DescribeDeltaSymbolGroup(obj)
if isinstance(obj, models.SymbolGroup):
return self._DescribeSymbolGroup(obj)
if isinstance(obj, (models.Symbol, models.DeltaSymbol)):
return self._DescribeSymbol(obj)
if hasattr(obj, '__iter__'):
return self._DescribeIterable(obj)
return iter((repr(obj),))
class DescriberText(Describer):
def __init__(self, verbose=False, recursive=False, summarize=True):
super().__init__()
self.verbose = verbose
self.recursive = recursive
self.summarize = summarize
def _DescribeSectionSizes(self,
unsummed_sections,
summed_sections,
section_sizes,
indent=''):
total_bytes, section_names = _GetSectionSizeInfo(unsummed_sections,
summed_sections,
section_sizes)
yield ''
yield '{}Section Sizes (Total={} ({} bytes)):'.format(
indent, _PrettySize(total_bytes), total_bytes)
for name in section_names:
size = section_sizes[name]
if name in unsummed_sections:
yield '{} {}: {} ({} bytes) (not included in totals)'.format(
indent, name, _PrettySize(size), size)
else:
notes = ''
if name not in summed_sections:
notes = ' (counted in .other)'
percent = _Divide(size, total_bytes)
yield '{} {}: {} ({} bytes) ({:.1%}){}'.format(
indent, name, _PrettySize(size), size, percent, notes)
if self.verbose:
yield ''
yield '{}Other section sizes:'.format(indent)
section_names = sorted(
k for k in section_sizes.keys() if k not in section_names)
for name in section_names:
notes = ''
if name in unsummed_sections:
notes = ' (not included in totals)'
elif name not in summed_sections:
notes = ' (counted in .other)'
yield '{} {}: {} ({} bytes){}'.format(
indent, name, _PrettySize(section_sizes[name]), section_sizes[name],
notes)
def _DescribeSymbol(self, sym, single_line=False):
container_str = sym.container_short_name
if container_str:
container_str = '<{}>'.format(container_str)
address = 'Group' if sym.IsGroup() else hex(sym.address)
last_field = ''
if sym.IsGroup():
last_field = 'count=%d' % len(sym)
else:
syms = [sym.before_symbol, sym.after_symbol] if sym.IsDelta() else [sym]
num_aliases = [s.num_aliases for s in syms if not s is None]
if num_aliases[0] != num_aliases[-1]: # If 2 distinct values.
last_field = 'num_aliases=%d->%d' % tuple(num_aliases)
elif num_aliases[0] > 1 or self.verbose:
last_field = 'num_aliases=%d' % num_aliases[0]
pss_field = _FormatPss(sym.pss, sym.IsDelta())
if sym.IsDelta():
b = sum(s.before_symbol.pss_without_padding if s.before_symbol else 0
for s in sym.IterLeafSymbols())
a = sum(s.after_symbol.pss_without_padding if s.after_symbol else 0
for s in sym.IterLeafSymbols())
pss_field = '{} ({}->{})'.format(pss_field, _FormatPss(b), _FormatPss(a))
elif sym.num_aliases > 1:
pss_field = '{} (size={})'.format(pss_field, sym.size)
if self.verbose:
if last_field:
last_field = ' ' + last_field
if sym.IsDelta():
yield '{}{}@{:<9s} {}{}'.format(container_str, sym.section, address,
pss_field, last_field)
else:
l = '{}{}@{:<9s} pss={} padding={}{}'.format(container_str,
sym.section, address,
pss_field, sym.padding,
last_field)
yield l
yield ' source_path={} \tobject_path={}'.format(
sym.source_path, sym.object_path)
if sym.name:
yield ' flags={} name={}'.format(sym.FlagsString(), sym.name)
if sym.full_name is not sym.name:
yield ' full_name={}'.format(sym.full_name)
elif sym.full_name:
yield ' flags={} full_name={}'.format(
sym.FlagsString(), sym.full_name)
else:
if last_field:
last_field = ' ({})'.format(last_field)
if sym.IsDelta():
pss_field = '{:<18}'.format(pss_field)
else:
pss_field = '{:<14}'.format(pss_field)
if single_line:
yield '{}{}@{:<9s} {} {}{}'.format(container_str, sym.section,
address, pss_field, sym.name,
last_field)
else:
path = sym.source_path or sym.object_path
if path and sym.generated_source:
path = '$root_gen_dir/' + path
path = path or '{no path}'
yield '{}{}@{:<9s} {} {}'.format(container_str, sym.section, address,
pss_field, path)
if sym.name:
yield ' {}{}'.format(sym.name, last_field)
def _DescribeSymbolGroupChildren(self, group, indent=0):
running_total = 0
running_percent = 0
is_delta = group.IsDelta()
all_groups = all(s.IsGroup() for s in group)
indent_prefix = '> ' * indent
diff_prefix = ''
total = group.pss
# is_default_sorted ==> sorted by abs(PSS) from largest to smallest.
if group.is_default_sorted:
# Skip long tail of small symbols (useful for diffs where aliases change).
# Long tail is defined as:
# * Accounts for < .5% of PSS
# * Symbols are smaller than 1.0 byte (by PSS)
# * Always show at least 50 symbols.
min_remaining_pss_to_show = max(1024.0, total / 1000.0 * 5)
min_symbol_pss_to_show = 1.0
min_symbols_to_show = 50
for index, s in enumerate(group):
if group.is_default_sorted and not self.verbose:
remaining_pss = total - running_total
if (index >= min_symbols_to_show and
abs(remaining_pss) < min_remaining_pss_to_show and
abs(s.pss) < min_symbol_pss_to_show):
remaining_count = len(group) - index
yield '{}Skipping {} tiny symbols comprising {} bytes.'.format(
indent_prefix, remaining_count, _FormatPss(remaining_pss))
break
if group.IsBss() or not s.IsBss():
running_total += s.pss
running_percent = _Divide(running_total, total)
for l in self._DescribeSymbol(s, single_line=all_groups):
if l[:4].isspace():
indent_size = 8 + len(indent_prefix) + len(diff_prefix)
yield '{} {}'.format(' ' * indent_size, l)
else:
if is_delta:
diff_prefix = models.DIFF_PREFIX_BY_STATUS[s.diff_status]
yield '{}{}{:<4} {:>8} {:7} {}'.format(
indent_prefix, diff_prefix, str(index) + ')',
_FormatPss(running_total), '({:.1%})'.format(running_percent), l)
if self.recursive and s.IsGroup():
for l in self._DescribeSymbolGroupChildren(s, indent=indent + 1):
yield l
@staticmethod
def _RelevantSections(section_names):
relevant_sections = [
s for s in models.SECTION_TO_SECTION_NAME.values() if s in section_names
]
if models.SECTION_MULTIPLE in relevant_sections:
relevant_sections.remove(models.SECTION_MULTIPLE)
return relevant_sections
def _DescribeSymbolGroup(self, group):
if self.summarize:
total_size = group.pss
pss_by_section = collections.defaultdict(float)
counts_by_section = collections.defaultdict(int)
for s in group.IterLeafSymbols():
pss_by_section[s.section_name] += s.pss
if not s.IsDelta() or s.diff_status is not models.DIFF_STATUS_UNCHANGED:
counts_by_section[s.section_name] += 1
# Apply this filter after calcualating size since an alias being removed
# causes some symbols to be UNCHANGED, yet have pss != 0.
if group.IsDelta():
group = group.WhereDiffStatusIs(models.DIFF_STATUS_UNCHANGED).Inverted()
if self.summarize:
histogram = Histogram()
for s in group:
histogram.Add(s.pss)
unique_paths = set()
for s in group.IterLeafSymbols():
# Ignore paths like foo/{shared}/2
if '{' not in s.object_path:
unique_paths.add(s.object_path)
if group.IsDelta():
before_unique, after_unique = group.CountUniqueSymbols()
unique_part = '{:,} -> {:,} unique'.format(before_unique, after_unique)
else:
unique_part = '{:,} unique'.format(group.CountUniqueSymbols())
relevant_sections = self._RelevantSections(pss_by_section)
size_summary = 'Sizes: ' + ' '.join(
'{}={:<10}'.format(k, _PrettySize(int(pss_by_section[k])))
for k in relevant_sections)
size_summary += ' total={:<10}'.format(_PrettySize(int(total_size)))
counts_summary = 'Counts: ' + ' '.join(
'{}={}'.format(k, counts_by_section[k]) for k in relevant_sections)
section_legend = ', '.join(
'{}={}'.format(models.SECTION_NAME_TO_SECTION[k], k)
for k in relevant_sections if k in models.SECTION_NAME_TO_SECTION)
summary_desc = itertools.chain(
['Showing {:,} symbols ({}) with total pss: {} bytes'.format(
len(group), unique_part, int(total_size))],
histogram.Generate(),
[size_summary.rstrip()],
[counts_summary],
['Number of unique paths: {}'.format(len(unique_paths))],
[''],
['Section Legend: {}'.format(section_legend)],
)
else:
summary_desc = ()
title_parts = ['Index', 'Running Total']
if group.container_name == '':
title_parts.append('Section@Address')
else:
title_parts.append('<Container>Section@Address')
if self.verbose:
title_parts.append('...')
else:
if group.IsDelta():
title_parts.append(u'\u0394 PSS (\u0394 size_without_padding)')
else:
title_parts.append('PSS')
title_parts.append('Path')
titles = ' | '.join(title_parts)
header_desc = (titles, '-' * 60)
children_desc = self._DescribeSymbolGroupChildren(group)
return itertools.chain(summary_desc, header_desc, children_desc)
def _DescribeDiffObjectPaths(self, delta_group):
paths_by_status = [set(), set(), set(), set()]
for s in delta_group.IterLeafSymbols():
path = s.source_path or s.object_path
# Ignore paths like foo/{shared}/2
if '{' not in path:
paths_by_status[s.diff_status].add(path)
# Initial paths sets are those where *any* symbol is
# unchanged/changed/added/removed.
unchanged, changed, added, removed = paths_by_status
# Consider a path with both adds & removes as "changed".
changed.update(added.intersection(removed))
# Consider a path added / removed only when all symbols are new/removed.
added.difference_update(unchanged)
added.difference_update(changed)
added.difference_update(removed)
removed.difference_update(unchanged)
removed.difference_update(changed)
removed.difference_update(added)
yield '{} paths added, {} removed, {} changed'.format(
len(added), len(removed), len(changed))
if self.verbose and added:
yield 'Added files:'
for p in sorted(added):
yield ' ' + p
if self.verbose and removed:
yield 'Removed files:'
for p in sorted(removed):
yield ' ' + p
if self.verbose and changed:
yield 'Changed files:'
for p in sorted(changed):
yield ' ' + p
def _DescribeDeltaSymbolGroup(self, delta_group):
if self.summarize:
num_inc = 0
num_dec = 0
counts_by_section = collections.defaultdict(int)
for sym in delta_group.IterLeafSymbols():
if sym.pss > 0:
num_inc += 1
elif sym.pss < 0:
num_dec += 1
status = sym.diff_status
if status == models.DIFF_STATUS_ADDED:
counts_by_section[sym.section_name] += 1
elif status == models.DIFF_STATUS_REMOVED:
counts_by_section[sym.section_name] -= 1
relevant_sections = self._RelevantSections(counts_by_section)
counts = delta_group.CountsByDiffStatus()
diff_status_msg = ('{} symbols added (+), {} changed (~), '
'{} removed (-), {} unchanged (not shown)').format(
counts[models.DIFF_STATUS_ADDED],
counts[models.DIFF_STATUS_CHANGED],
counts[models.DIFF_STATUS_REMOVED],
counts[models.DIFF_STATUS_UNCHANGED])
counts_by_section_msg = 'Added/Removed by section: ' + ' '.join(
'{}: {:+}'.format(k, counts_by_section[k]) for k in relevant_sections)
num_unique_before_symbols, num_unique_after_symbols = (
delta_group.CountUniqueSymbols())
diff_summary_desc = [
diff_status_msg,
counts_by_section_msg,
'Of changed symbols, {} grew, {} shrank'.format(num_inc, num_dec),
'Number of unique symbols {} -> {} ({:+})'.format(
num_unique_before_symbols, num_unique_after_symbols,
num_unique_after_symbols - num_unique_before_symbols),
]
path_delta_desc = itertools.chain(
self._DescribeDiffObjectPaths(delta_group),
('',))
else:
diff_summary_desc = ()
path_delta_desc = ()
group_desc = self._DescribeSymbolGroup(delta_group)
return itertools.chain(diff_summary_desc, path_delta_desc, group_desc)
def _DescribeDeltaDict(self, data_name, before_dict, after_dict, indent=''):
common_items = {
k: v
for k, v in before_dict.items() if after_dict.get(k) == v
}
before_items = {
k: v
for k, v in before_dict.items() if k not in common_items
}
after_items = {k: v for k, v in after_dict.items() if k not in common_items}
return itertools.chain(
(indent + 'Common %s:' % data_name, ),
(indent + ' %s' % line for line in DescribeDict(common_items)),
(indent + 'Old %s:' % data_name, ),
(indent + ' %s' % line for line in DescribeDict(before_items)),
(indent + 'New %s:' % data_name, ),
(indent + ' %s' % line for line in DescribeDict(after_items)))
def _DescribeDeltaSizeInfo(self, diff):
desc_list = []
# Describe |build_config| and each container. If there is only one container
# then support legacy output by reporting |build_config| as part of the
# first container's metadata.
if len(diff.containers) > 1:
desc_list.append(
self._DescribeDeltaDict('Build config', diff.before.build_config,
diff.after.build_config))
for c in diff.containers:
desc_list.append(('', ))
desc_list.append(('Container<%s>: %s' % (c.short_name, c.name), ))
desc_list.append(
self._DescribeDeltaDict('Metadata',
c.before.metadata,
c.after.metadata,
indent=' '))
unsummed_sections, summed_sections = c.ClassifySections()
desc_list.append(
self._DescribeSectionSizes(unsummed_sections,
summed_sections,
c.section_sizes,
indent=' '))
else: # Legacy output for single Container case.
desc_list.append(
self._DescribeDeltaDict('Metadata', diff.before.metadata_legacy,
diff.after.metadata_legacy))
c = diff.containers[0]
unsummed_sections, summed_sections = c.ClassifySections()
desc_list.append(
self._DescribeSectionSizes(unsummed_sections, summed_sections,
c.section_sizes))
desc_list.append(('', ))
desc_list.append(self.GenerateLines(diff.symbols))
return itertools.chain.from_iterable(desc_list)
def _DescribeSizeInfo(self, size_info):
desc_list = []
# Describe |build_config| and each container. If there is only one container
# then support legacy output by reporting |build_config| as part of the
# first container's metadata.
if len(size_info.containers) > 1:
desc_list.append(('Build Configs:', ))
desc_list.append(' %s' % line
for line in DescribeDict(size_info.build_config))
containers = size_info.containers
else:
containers = [
models.Container(name='',
metadata=size_info.metadata_legacy,
section_sizes=size_info.containers[0].section_sizes)
]
for c in containers:
if c.name:
desc_list.append(('', ))
desc_list.append(('Container<%s>: %s' % (c.short_name, c.name), ))
desc_list.append(('Metadata:', ))
desc_list.append(' %s' % line for line in DescribeDict(c.metadata))
unsummed_sections, summed_sections = c.ClassifySections()
desc_list.append(
self._DescribeSectionSizes(unsummed_sections, summed_sections,
c.section_sizes))
if self.verbose:
desc_list.append(('', ))
desc_list.append(data_quality.DescribeSizeInfoCoverage(size_info))
desc_list.append(('', ))
desc_list.append(self.GenerateLines(size_info.symbols))
return itertools.chain.from_iterable(desc_list)
class DescriberCsv(Describer):
def __init__(self, verbose=False):
super().__init__()
self.verbose = verbose
self.stringio = io.StringIO()
self.csv_writer = csv.writer(self.stringio)
def _RenderCsv(self, data):
self.stringio.truncate(0)
self.stringio.seek(0)
self.csv_writer.writerow(data)
return self.stringio.getvalue().rstrip()
def _DescribeSectionSizes(self, unsummed_sections, summed_section,
section_sizes):
_, significant_section_names = _GetSectionSizeInfo(unsummed_sections,
summed_section,
section_sizes)
if self.verbose:
significant_set = set(significant_section_names)
section_names = sorted(section_sizes.keys())
yield self._RenderCsv(['Name', 'Size', 'IsSignificant'])
for name in section_names:
size = section_sizes[name]
yield self._RenderCsv([name, size, int(name in significant_set)])
else:
yield self._RenderCsv(['Name', 'Size'])
for name in significant_section_names:
size = section_sizes[name]
yield self._RenderCsv([name, size])
def _DescribeDeltaSizeInfo(self, diff):
desc_list = []
for c in diff.containers:
unsummed_sections, summed_sections = c.ClassifySections()
desc_list.append(
self._DescribeSectionSizes(unsummed_sections, summed_sections,
c.section_sizes))
desc_list.append(('', ))
desc_list.append(self.GenerateLines(diff.symbols))
return itertools.chain.from_iterable(desc_list)
def _DescribeSizeInfo(self, size_info):
desc_list = []
for c in size_info.containers:
unsummed_sections, summed_sections = c.ClassifySections()
desc_list.append(
self._DescribeSectionSizes(unsummed_sections, summed_sections,
c.section_sizes))
desc_list.append(('', ))
desc_list.append(self.GenerateLines(size_info.symbols))
return itertools.chain.from_iterable(desc_list)
def _DescribeDeltaSymbolGroup(self, delta_group):
yield self._RenderSymbolHeader(True);
# Apply filter to remove UNCHANGED groups.
delta_group = delta_group.WhereDiffStatusIs(
models.DIFF_STATUS_UNCHANGED).Inverted()
for sym in delta_group:
yield self._RenderSymbolData(sym)
def _DescribeSymbolGroup(self, group):
yield self._RenderSymbolHeader(False);
for sym in group:
yield self._RenderSymbolData(sym)
def _DescribeSymbol(self, sym, single_line=False):
yield self._RenderSymbolHeader(sym.IsDelta());
yield self._RenderSymbolData(sym)
def _RenderSymbolHeader(self, isDelta):
fields = []
fields.append('GroupCount')
fields.append('Address')
fields.append('SizeWithoutPadding')
fields.append('Padding')
if isDelta:
fields += ['BeforeNumAliases', 'AfterNumAliases']
else:
fields.append('NumAliases')
fields.append('PSS')
fields.append('Section')
if self.verbose:
fields.append('Flags')
fields.append('SourcePath')
fields.append('ObjectPath')
fields.append('Name')
if self.verbose:
fields.append('FullName')
return self._RenderCsv(fields)
def _RenderSymbolData(self, sym):
data = []
data.append(len(sym) if sym.IsGroup() else None)
data.append(None if sym.IsGroup() else hex(sym.address))
data.append(sym.size_without_padding)
data.append(sym.padding)
if sym.IsDelta():
b, a = (None, None) if sym.IsGroup() else (sym.before_symbol,
sym.after_symbol)
data.append(b.num_aliases if b else None)
data.append(a.num_aliases if a else None)
else:
data.append(sym.num_aliases)
data.append(round(sym.pss, 3))
data.append(sym.section)
if self.verbose:
data.append(sym.FlagsString())
data.append(sym.source_path);
data.append(sym.object_path);
data.append(sym.name)
if self.verbose:
data.append(sym.full_name)
return self._RenderCsv(data)
def _UtcToLocal(utc):
epoch = time.mktime(utc.timetuple())
offset = (datetime.datetime.fromtimestamp(epoch) -
datetime.datetime.utcfromtimestamp(epoch))
return utc + offset
def DescribeDict(input_dict):
display_dict = {}
for k, v in input_dict.items():
if k == models.METADATA_ELF_MTIME:
timestamp_obj = datetime.datetime.utcfromtimestamp(v)
display_dict[k] = (
_UtcToLocal(timestamp_obj).strftime('%Y-%m-%d %H:%M:%S'))
elif isinstance(v, str):
display_dict[k] = v
elif isinstance(v, list):
if v:
if isinstance(v[0], str):
display_dict[k] = ' '.join(str(t) for t in v)
else:
display_dict[k] = repr(v)
else:
display_dict[k] = ''
else:
display_dict[k] = repr(v)
return sorted('%s=%s' % t for t in display_dict.items())
def GenerateLines(obj, verbose=False, recursive=False, summarize=True,
format_name='text'):
"""Returns an iterable of lines (without \n) that describes |obj|."""
if format_name == 'text':
d = DescriberText(verbose=verbose, recursive=recursive, summarize=summarize)
elif format_name == 'csv':
d = DescriberCsv(verbose=verbose)
else:
raise ValueError('Unknown format_name \'{}\''.format(format_name));
return d.GenerateLines(obj)
def WriteLines(lines, func):
for l in lines:
func(l)
func('\n')