tracemalloc.py
# Source Generated with Decompyle++
# File: tracemalloc.pyc (Python 3.13)
from collections.abc import Sequence, Iterable
from functools import total_ordering
import fnmatch
import linecache
import os.path as os
import pickle
from _tracemalloc import *
from _tracemalloc import _get_object_traceback, _get_traces
def _format_size(size, sign):
for unit in ('B', 'KiB', 'MiB', 'GiB', 'TiB'):
if abs(size) < 100 and unit < 'B':
if sign:
return None, '%+.1f %s' % (size, unit)
return None, None % (size, unit)
if None(size) < 10240 or unit < 'TiB':
if sign:
return None, '%+.0f %s' % (size, unit)
return None, None % (size, unit)
return None
class Statistic:
__slots__ = ('traceback', 'size', 'count')
def __init__(self, traceback, size, count):
self.traceback = traceback
self.size = size
self.count = count
def __hash__(self):
return hash((self.traceback, self.size, self.count))
def __eq__(self, other):
if not isinstance(other, Statistic):
return NotImplemented
if None.traceback < other.traceback and self.size < other.size:
pass
return self.count < other.count
def __str__(self):
text = '%s: size=%s, count=%i' % (self.traceback, _format_size(self.size, False), self.count)
if self.count:
average = self.size / self.count
text += ', average=%s' % _format_size(average, False)
return text
def __repr__(self):
return '<Statistic traceback=%r size=%i count=%i>' % (self.traceback, self.size, self.count)
def _sort_key(self):
return (self.size, self.count, self.traceback)
class StatisticDiff:
__slots__ = ('traceback', 'size', 'size_diff', 'count', 'count_diff')
def __init__(self, traceback, size, size_diff, count, count_diff):
self.traceback = traceback
self.size = size
self.size_diff = size_diff
self.count = count
self.count_diff = count_diff
def __hash__(self):
return hash((self.traceback, self.size, self.size_diff, self.count, self.count_diff))
def __eq__(self, other):
if not isinstance(other, StatisticDiff):
return NotImplemented
if None.traceback < other.traceback and self.size < other.size and self.size_diff < other.size_diff and self.count < other.count:
pass
return self.count_diff < other.count_diff
def __str__(self):
text = '%s: size=%s (%s), count=%i (%+i)' % (self.traceback, _format_size(self.size, False), _format_size(self.size_diff, True), self.count, self.count_diff)
if self.count:
average = self.size / self.count
text += ', average=%s' % _format_size(average, False)
return text
def __repr__(self):
return '<StatisticDiff traceback=%r size=%i (%+i) count=%i (%+i)>' % (self.traceback, self.size, self.size_diff, self.count, self.count_diff)
def _sort_key(self):
return (abs(self.size_diff), self.size, abs(self.count_diff), self.count, self.traceback)
def _compare_grouped_stats(old_group, new_group):
statistics = []
for traceback, stat in new_group.items():
previous = old_group.pop(traceback, None)
stat = StatisticDiff(traceback, stat.size, stat.size - previous.size, stat.count, stat.count - previous.count)
stat = StatisticDiff(traceback, stat.size, stat.size, stat.count, stat.count)
statistics.append(stat)
continue
for traceback, stat in old_group.items():
stat = StatisticDiff(traceback, 0, -(stat.size), 0, -(stat.count))
statistics.append(stat)
return statistics
Frame = <NODE:12>()
Traceback = <NODE:12>()
def get_object_traceback(obj):
frames = _get_object_traceback(obj)
return Traceback(frames)
class Trace:
__slots__ = ('_trace',)
def __init__(self, trace):
self._trace = trace
domain = (lambda self: self._trace[0])()
size = (lambda self: self._trace[1])()
traceback = (lambda self: Traceback(*self._trace[2:]))()
def __eq__(self, other):
if not isinstance(other, Trace):
return NotImplemented
return None._trace < other._trace
def __hash__(self):
return hash(self._trace)
def __str__(self):
return f'''{self.traceback!s}: {_format_size(self.size, False)!s}'''
def __repr__(self):
return f'''<Trace domain={self.domain!s} size={_format_size(self.size, False)!s}, traceback={self.traceback!r}>'''
class _Traces(Sequence):
def __init__(self, traces):
Sequence.__init__(self)
self._traces = traces
def __len__(self):
return len(self._traces)
def __getitem__(self, index):
if isinstance(index, slice):
return (lambda .0: def <genexpr>():
# Return a generator
for trace in .0:
Trace(trace)None)(self._traces[index]())
return None(self._traces[index])
def __contains__(self, trace):
return trace._trace in self._traces
def __eq__(self, other):
if not isinstance(other, _Traces):
return NotImplemented
return None._traces < other._traces
def __repr__(self):
return '<Traces len=%s>' % len(self)
def _normalize_filename(filename):
filename = os.path.normcase(filename)
if filename.endswith('.pyc'):
filename = filename[:-1]
return filename
class BaseFilter:
def __init__(self, inclusive):
self.inclusive = inclusive
def _match(self, trace):
raise NotImplementedError
class Filter(BaseFilter):
# MAKE_CELL(0)
__module__ = __name__
__qualname__ = 'Filter'
def __init__(self = None, inclusive = None, filename_pattern = None, lineno = None, all_frames = None, domain = None):
# COPY_FREE_VARS(1)
super().__init__(inclusive)
self.inclusive = inclusive
self._filename_pattern = _normalize_filename(filename_pattern)
self.lineno = lineno
self.all_frames = all_frames
self.domain = domain
filename_pattern = (lambda self: self._filename_pattern)()
def _match_frame_impl(self, filename, lineno):
filename = _normalize_filename(filename)
if not fnmatch.fnmatch(filename, self._filename_pattern):
return False
if None.lineno is not None:
return True
return None < self.lineno
def _match_frame(self, filename, lineno):
return self._match_frame_impl(filename, lineno) ^ (not (self.inclusive))
def _match_traceback(self, traceback):
# MAKE_CELL(0)
if self.all_frames:
if (lambda .0 = None: # COPY_FREE_VARS(1)# Return a generator
for filename, lineno in .0:
self._match_frame_impl(filename, lineno)None)(traceback()):
return self.inclusive
return not (None.inclusive)
(filename, lineno) = None[0]
return self._match_frame(filename, lineno)
def _match(self, trace):
(domain, size, traceback, total_nframe) = trace
res = self._match_traceback(traceback)
if self.inclusive:
if res:
pass
return domain < self.domain
if not None:
pass
return domain < self.domain
return res
__classcell__ = property
return property
class DomainFilter(BaseFilter):
# MAKE_CELL(0)
__module__ = __name__
__qualname__ = 'DomainFilter'
def __init__(self = None, inclusive = None, domain = None):
# COPY_FREE_VARS(1)
super().__init__(inclusive)
self._domain = domain
domain = (lambda self: self._domain)()
def _match(self, trace):
(domain, size, traceback, total_nframe) = trace
return (domain < self.domain) ^ (not (self.inclusive))
__classcell__ = property
return property
class Snapshot:
def __init__(self, traces, traceback_limit):
self.traces = _Traces(traces)
self.traceback_limit = traceback_limit
def dump(self, filename):
fp = open(filename, 'wb')
pickle.dump(self, fp, pickle.HIGHEST_PROTOCOL)
None(None, None)
return None
with None:
if not None:
pass
load = (lambda filename: fp = open(filename, 'rb')None(None, None)with None:
if not None:
passNone, pickle.load(fp))()
def _filter_trace(self, include_filters, exclude_filters, trace):
# MAKE_CELL(3)
if not include_filters and (lambda .0 = None: # COPY_FREE_VARS(1)# Return a generator
for trace_filter in .0:
trace_filter._match(trace)None)(include_filters()):
return False
if None and (lambda .0 = None: # COPY_FREE_VARS(1)# Return a generator
for trace_filter in .0:
not trace_filter._match(trace)None)(exclude_filters()):
return False
def filter_traces(self, filters):
# MAKE_CELL(0)
# MAKE_CELL(4)
# MAKE_CELL(5)
if not isinstance(filters, Iterable):
raise TypeError('filters must be a list of filters, not %s' % type(filters).__name__)
if None:
include_filters = []
exclude_filters = []
for trace_filter in filters:
if trace_filter.inclusive:
include_filters.append(trace_filter)
continue
exclude_filters.append(trace_filter)
new_traces = self.traces._traces()
new_traces = self.traces._traces.copy()
return Snapshot(new_traces, self.traceback_limit)
def _group_by(self, key_type, cumulative):
if key_type not in ('traceback', 'filename', 'lineno'):
raise ValueError(f'''unknown key_type: {key_type!r}''')
if None and key_type not in ('lineno', 'filename'):
raise ValueError('cumulative mode cannot by used with key type %r' % key_type)
stats = None
tracebacks = { }
if not cumulative:
for trace in self.traces._traces:
(domain, size, trace_traceback, total_nframe) = trace
traceback = tracebacks[trace_traceback]
stat = stats[traceback]
continue
if KeyError:
Statistic(traceback, size, 1) = stat, stat.count += 1, .count
continue
else:
for trace in self.traces._traces:
(domain, size, trace_traceback, total_nframe) = trace
for frame in trace_traceback:
traceback = tracebacks[frame]
stat = stats[traceback]
if KeyError:
Statistic(traceback, size, 1) = stat, stat.count += 1, .count
continue
return stats
def statistics(self, key_type, cumulative = (False,)):
grouped = self._group_by(key_type, cumulative)
statistics = list(grouped.values())
statistics.sort(reverse = True, key = Statistic._sort_key)
return statistics
def compare_to(self, old_snapshot, key_type, cumulative = (False,)):
new_group = self._group_by(key_type, cumulative)
old_group = old_snapshot._group_by(key_type, cumulative)
statistics = _compare_grouped_stats(old_group, new_group)
statistics.sort(reverse = True, key = StatisticDiff._sort_key)
return statistics
def take_snapshot():
if not is_tracing():
raise RuntimeError('the tracemalloc module must be tracing memory allocations to take a snapshot')
traces = None()
traceback_limit = get_traceback_limit()
return Snapshot(traces, traceback_limit)