Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-21 15:45
📄 Classifiers.py from guppy.etc.Descriptor import property_nondata class Classifier: def __init__(self, mod, name, cli=None, supers=(), depends=(), with_referrers=False): self.mod = mod self.name = name if cli is not None: self.cli = cli # Set of all super-classifiers (including self). # The partial order is defined in Notes Aug 30 2005. self.super_classifiers = mod.ImpSet.immnodeset([self]) if supers: for s in supers: self.super_classifiers \|= s.super_classifiers else: # The Unity classifier is super of all, but we must add it only # if not supers specified; init of ByUnity itself depends on this. self.super_classifiers \|= [mod.Use.Unity.classifier] # The classifiers that self depends on. for d in depends: if d.with_referrers: with_referrers = True break # True if we need to setup referrers before calling (the) low-level classifier. self.with_referrers = with_referrers if with_referrers: self.call_with_referrers = mod.View.call_with_referrers def call_with_referrers(self, x, f): # Default is to not use referrers. return f(x) # This is not redefined by subclass unless they set cli property. def _get_cli(self): # This may be defined by subclass w/o setting cli property. return self.get_cli() cli = property_nondata(_get_cli) def get_alt(self, kind, alt): # Get alternative kind for a kind with self as fam.classifier. return self.mod.alt(kind, alt) def get_dictof(self, kind): name = '%s.dictof' % self.name er = self.mod.mker_memoized( name, lambda: self.mod._er_by_(ByDictOwner, self.mod, name, self)) return er.classifier.dictof(kind) def get_kind(self, k): # Make an equivalence class from low-level classification return self.family(k) def get_kindarg(self, kind): # Inverse of get_kind cla, ka, cmp = kind.get_ckc() if cla is not self: raise ValueError( 'get_kindarg: argument with classifier %r expected' % self) return ka def get_reprname(self): return '%s%s' % (self.mod.Use.reprefix, self.name) def get_sokind(self, er, args, kwds): k = er(args, *kwds) return CallableSoKind(er, (k,)) def get_sokindrepr(self, sokind): # Get the representation of a set of kinds # from this classifier / eqv. relation. return '%s.sokind%s' % (self.get_reprname(), ''.join(['(%s)' % self.get_userkindargrepr(k) for k in sokind.kinds])) def get_tabheader(self, ctx=''): # If ctx = 'and', get the table header when used as a part of the 'and' classifier. # It is sometimes a more compact or parenthesised version of the usual tab header. return self.get_byname() def get_tabrendering(self, cla, ctx=''): # If ctx = 'and', get the table rendering when used as a part of the 'and' classifier # sometimes we want to enclose something in parenthesises. return cla.brief def get_userkind(self, args, *kwds): # Make a kind from user-level arguments return self.family(args, *kwds) def get_userkindarg(self, kind): return kind.arg def get_userkindargrepr(self, kind): return repr(self.get_userkindarg(kind)) def partition(self, iterable): items = [] for k, v in self.partition_cli(iterable): k = self.get_kind(k) v = self.mod.Use.idset(v, er=self.er) items.append((k, v)) return items def partition_cli(self, a): ep = self.call_with_referrers( a, self.cli.epartition) return [(k, ep[k]) for k in ep.get_domain()] def relimg(self, X): p = self.partition_cli(X) kinds = [self.get_kind(k) for k, v in p] # could be more efficient return self.mod.Use.union(kinds, maximized=1) def select_cli(self, a, b, cmp='=='): return self.call_with_referrers( a, lambda a: self.cli.select(a, b, cmp)) def select_ids(self, X, k, alt=None): r = self.mod.Use.idset(self.select_cli(X.nodes, k, alt)) return r class SoKind(object): def __init__(self, er, kinds): self.er = er self.classifier = er.classifier self.kinds = kinds self.clikinds = self.classifier.mod.ImpSet.immnodeset( [self.classifier.get_kindarg(kind) for kind in kinds]) def __eq__(self, other): if not isinstance(other, SoKind): return False if self.classifier != other.classifier: return False a = self.classifier.mod.Use.union(self.kinds) b = self.classifier.mod.Use.union(other.kinds) return a == b def __hash__(self): return hash(repr(self)) def __repr__(self): return self.classifier.get_sokindrepr(self) def _get_refdby(self): return self.er.refdby(self) refdby = property(_get_refdby) class CallableSoKind(SoKind): def __call__(self, args, *kwds): k = self.er(args, *kwds) return self.__class__(self.er, self.kinds + (k,)) class SoNoKind(SoKind): def __repr__(self): return '%s%s' % (self.classifier.mod.Use.reprefix, 'sonokind') class QuickSoKind(SoKind): # Quicker to make than SoKind, # when clikinds is available but not kinds. __slots__ = 'classifier', 'clikinds' def __init__(self, classifier, clikinds): self.classifier = classifier self.clikinds = clikinds def _get_er(self): return self.classifier.er er = property(_get_er) def _get_kinds(self): return tuple([self.classifier.get_kind(k) for k in self.clikinds]) kinds = property(_get_kinds) class IdentityFamily: # Holds a single object node def __init__(self, mod, classifier): self.defrefining(mod.Use.Anything) self.classifier = classifier def _ge_ATOM(self, a, b): # b is known to not be Nothing since its c_le doesn't call back if self is b.fam: return a.arg is b.arg return b.fam.supercl is not None and b.fam.supercl <= a def _le_ATOM(self, a, b): # b is known to not be Nothing since its c_ge doesn't call back if self is b.fam: return a.arg is b.arg return self.supercl is not None and self.supercl <= b def c_contains(self, a, b): return b is a.arg def _and_ID(self, a, b): # Just a possible optimization return self.mod.Use.idset(b.nodes & [a.arg]) def c_get_brief(self, a): return '<id %s>' % hex(id(a.arg)) def c_repr(self, a): return '%s(%s)' % (self.classifier.get_reprname(), self.classifier.get_userkindargrepr(a)) class ByIdentity(Classifier): def __init__(self, mod, name): Classifier.__init__(self, mod, name, mod.hv.cli_id()) self.family = mod.fam_mixin_argatom(IdentityFamily, self) # self.super_classifiers = mod.Use.Anything # Replace whatever Classifer had set it to def get_byname(self): return 'object identity' def get_tabheader(self, ctx=''): return 'Object Identity' def get_userkind(self, address): return self.get_kind(self.mod.View.obj_at(address)) def get_userkindarg(self, kind): return id(kind.arg) def get_userkindargrepr(self, kind): return hex(self.get_userkindarg(kind)) class ByIdentitySet(Classifier): # Classification is, conceptually, a singleton immnodeset of each object # What this is used to is: # to be able to use an iso() set as a kind # combined with other classifiers eg in dictof, biper # The ckc returned from an iso is then # this classifier, nodes of iso, '<=' # The cmp indicates subset # select thus selects every object for which it singleton is a subset of the set given # which is optimized to select the object that are members of that set # and may be optimized at higher levels to invoke the low-level set intersection def __init__(self, mod, name): Classifier.__init__(self, mod, name, mod.hv.cli_idset()) self.family = mod.Use.idset # self.super_classifiers = mod.Use.Anything # Replace whatever Classifer had set it to def get_byname(self): return 'by identity set' def get_userkind(self, node): return self.family(self.mod.ImpSet.immnodeset([node])) def relimg(self, X): p = self.partition_cli(X) k = self.mod.ImpSet.immnodeset_union([k for k, v in p]) return self.family(k) class PyObjectFamily: def __init__(self, mod, classifier): self.classifier = classifier def c_contains(self, a, b): return True def c_get_idpart_header(self, a): return 'Kind: Name/Value/Address' def c_get_idpart_label(self, a): return '' def c_get_idpart_render(self, a): def render(x): x = self.mod.Use.iso(x) r = x.brief.lstrip('<1 ').rstrip('>') return r return render def c_get_brief(self, a): return '<Anything>' def c_repr(self, a): return '%s%s' % (self.mod.Use.reprefix, 'Anything') def _and_ID(self, a, b): # Optimization shortcut # shcould be made in classifer.select return b class ByUnity(Classifier): """byunity Classify by <unity>. The classification returned for every object is <Anything>.""" def __init__(self, mod, name): Classifier.__init__(self, mod, name, mod.hv.cli_none(), # Must make it avoid referring to Unity ! supers=[self] ) self.family = mod.fam_mixin_argatom(PyObjectFamily, self) def get_byname(self): return 'unity' def get_tabheader(self, ctx=''): return '<unclassified>' def get_userkind(self, args): return self.mod.Use.Anything def get_userkindarg(self, kind): return None class IndiSizeFamily: def __init__(self, mod, classifier): self.defrefining(mod.Use.Anything) self.classifier = classifier def __call__(self, a): a = int(a) return self.mod.AtomFamily.__call__(self, a) def c_alt(self, a, alt): return self.classifier.get_alt(a, alt) def c_contains(self, a, b): return a.arg == self.classifier.cli.classify(b) def c_get_render(self, a): return self.mod.summary_str(a.arg) def c_get_brief(self, a): return '<size = %d>' % a.arg def c_get_brief_alt(self, a, alt): return '<size %s %d>' % (alt, a.arg) def c_repr(self, a): return '%s(%s)' % (self.classifier.get_reprname(), a.arg) class ByIndiSize(Classifier): """byindisize Classify by <individual size>. The classification will be individual memory size of the object.""" def __init__(self, mod, name): Classifier.__init__(self, mod, name) self.family = mod.fam_mixin_argatom(IndiSizeFamily, self) def get_byname(self): return 'individual size' def get_cli(self): return self.mod.hv.cli_indisize({}) def get_tabheader(self, ctx=''): return 'Individual Size' def get_tabrendering(self, cla, ctx=''): if ctx: return '%d' % cla.arg else: return '%9d' % cla.arg class TypeFamily: def __init__(self, mod, classifier): self.defrefining(mod.Use.Anything) self.classifier = classifier self.range = mod.fam_Family(self) def __call__(self, a): if not isinstance(a, type): raise TypeError("Argument should be a type.") return self.Set(self, a) def c_alt(self, a, alt): return self.classifier.get_alt(a, alt) def c_contains(self, a, b): return type(b) is a.arg def c_get_render(self, a): return self.mod.summary_str(a.arg) def c_get_brief(self, a): return self.mod.summary_str(type(a.arg))(a.arg) def c_get_brief_alt(self, a, alt): x = { '<': 'strict subtype', '<=': 'subtype', '>=': 'supertype', '>': 'strict supertype' }[alt] return '<%s of %s>' % (x, self.c_get_brief(a)) def c_repr(self, a): return self.classifier.get_repr(a) class ByType(Classifier): """bytype Classify by <type>. The classification will be the type of the object.""" def __init__(self, mod, name): Classifier.__init__(self, mod, name, mod.hv.cli_type()) self.family = mod.fam_mixin_argatom(TypeFamily, self) def get_attr_for_er(self, name): try: ty = getattr(self.mod.types, name+'Type') except AttributeError: ty = getattr(self.mod.builtins, name.lower()) return self.get_userkind(ty) def get_byname(self): return 'type' def get_repr(self, kind): t = kind.arg rn = self.get_reprname() if t in self.mod.invtypemod: return '%s.%s' % (rn, self.mod.invtypemod[t]) else: return '%s(%r)' % (rn, self.get_userkindarg(kind)) def get_tabheader(self, ctx=''): return 'Type' def get_userkind(self, kind): kind = self.mod.tc_adapt(kind) return self.family(kind) def get_userkindarg(self, kind): # A representation that is a valid userkind arg. return self.mod.Use.tc_repr(kind.arg) class OwnedDictFamily: def __init__(self, mod): self.defrefidis(mod.Use.Type(dict)) def _get_ownerkind(self, a): return a.arg def c_alt(self, a, alt): return self(a.arg.alt(alt)) def c_get_render(self, a): ka = self._get_ownerkind(a) if ka is self.mod.Use.Nothing: return self.mod.Use.Type.Dict.get_render() else: ownrender = ka.get_render() def render(x): ret = ownrender(self.mod.Use.iso(x).owners.theone) if '.' in ret: ret = '..'+ret.split('.')[-1] return ret return render if ka == self.mod.fam_Type(self.types.ModuleType): modrender = self.mod.Use.Type.Module.get_render() def render(x): return modrender(self.mod.Use.iso(x).owners.theone) return render else: return self.mod.Use.Type.Dict.get_render() def c_get_brief(self, a): ka = self._get_ownerkind(a) if ka is self.mod.Use.Nothing: return 'dict (no owner)' else: return 'dict of ' + ka.brief def c_get_ckc(self, a): cla, k, cmp = a.arg.get_ckc() if cmp != '==': cla, k, cmp = a.arg.biper(0).get_ckc() docla = cla.er.dictof.classifier if a.arg is self.mod.Use.Nothing: k = docla.notownedtag return docla, k, cmp def c_get_str_for(self, a, b): return self.c_get_brief(a) def c_get_idpart_render(self, a): ka = self._get_ownerkind(a) if ka is not self.mod.Use.Nothing: owner_render = ka.fam.c_get_idpart_render(ka) def render(x): return owner_render(self.mod.Use.iso(x).owners.theone) return render else: b = self.mod._parent.Spec.Type.Dict return b.fam.c_get_idpart_render(b) def c_get_idpart_header(self, a): ka = self._get_ownerkind(a) if ka is self.mod.Use.Nothing: return 'AddressLength' else: return 'Owner ' + ka.fam.c_get_idpart_header(ka) def c_repr(self, a): ka = self._get_ownerkind(a) ra = repr(ka) if ra.startswith('~'): ra = '(%s)' % ra return '%s.dictof' % ra class ByDictOwner(Classifier): def __init__(self, mod, name, ownerclassifier): Classifier.__init__(self, mod, name, depends=[ownerclassifier]) self.ownerclassifier = ownerclassifier self.hv = mod.View.hv self.ownership = mod.View.dict_ownership self.family = mod.dictof self.notdict = mod.notdict self.dictofnothing = mod.dictofnothing # Hashable unique tags # Using sets methods since I dont want our hiding tag here! # Confuses heapg. Note feb 3 2006 self.notdicttag = mod.ImpSet.immnodeset([[]]) self.notownedtag = mod.ImpSet.immnodeset([[]]) def get_byname(self): return '[dict of] %s' % self.ownerclassifier.get_byname() def get_cli(self): cli = self.hv.cli_dictof(self.ownership, self.ownerclassifier.cli, self.notdicttag, self.notownedtag) return cli def get_kind(self, k): if k is self.notdicttag: return self.notdict elif k is self.notownedtag: return self.dictofnothing else: return self.family(self.ownerclassifier.get_kind(k)) def get_kindarg(self, kind): if kind is self.notdict: return self.notdicttag elif kind is self.dictofnothing: return self.notownedtag else: return self.ownerclassifier.get_kindarg(kind.arg) def get_tabheader(self, ctx=''): return 'Dict of %s' % self.ownerclassifier.get_tabheader(ctx) def get_tabrendering(self, kind, ctx=''): if kind is self.notdict: r = kind.brief elif kind is self.dictofnothing: r = 'dict (no owner)' else: r = 'dict of ' + \ self.ownerclassifier.get_tabrendering(kind.arg, ctx) return r def get_userkind(self, k): if k is None: return self.notdict elif k is self.mod.Use.Nothing: return self.dictofnothing else: return self.family(k) def get_userkindarg(self, kind): if kind is self.notdict: return None elif kind is self.dictofnothing: return self.mod.Use.Nothing else: return kind.arg def owners(self, X): p = self.partition_cli(X.nodes) ns = self.mod.ImpSet.mutnodeset() drg = self.ownership for k in X.nodes: t = drg[k] if not t: self.mod.hv.update_dictowners(drg) t = drg[k] if t: v = t[0] if v is not None: ns.add(v) return self.mod.Use.idset(ns) class ByClassOrDictOwner(Classifier): """byclodo Classify by <type or dict owner>. The classification is performed as follows: 1. If the object is not a dictionary, the classification will be the type of the object. 2. The object is a dictionary. The referrers of the object are searched to find one that 'owns' the dictionary. That is, typically, that the dict is the __dict__ attribute of the owner. If no such owner is found, the type 'dict' will be the classification. If an owner is found, a special object that indicates the classification of the owner will be returned. The classification of the owner will be done by class. (As byclass.)""" def __init__(self, mod, name): a = mod.Type d = a.dictof ad = (a & d).classifier sup = a.classifier Classifier.__init__(self, mod, name, cli=None, supers=[sup], depends=[ad]) self.sup = sup self.a = a.classifier self.d = d.classifier self.ad = ad def get_byname(self): return '[dict of] class' def get_cli(self): return self.ad.cli def get_kind(self, xxx_todo_changeme): (ka, kd) = xxx_todo_changeme if kd is self.d.notdicttag: return self.a.get_kind(ka) else: return self.d.get_kind(kd) def get_kindarg(self, kind): if kind.fam is self.d.family: ka = dict kd = self.d.get_kindarg(kind) else: ka = self.a.get_kindarg(kind) kd = self.d.notdicttag return (ka, kd) def get_tabheader(self, ctx=''): return 'Kind (class / dict of class)' def get_userkind(self, kind=None, dictof=None): try: if kind is None and dictof is not None: if dictof == (): do = self.mod.UniSet.Nothing else: do = self.sup.get_userkind(dictof) return self.d.get_userkind(do) elif kind is not None and dictof is None: kind = self.mod.tc_adapt(kind) if kind is dict: raise TypeError( 'dict is not an equivalence class of Clodo, use dictof=() etc') return self.sup.get_kind(kind) else: raise TypeError except TypeError: raise TypeError("""\ Argument should be either <type except dict> dictof=<type> dictof=()""") def get_userkindargrepr(self, kind): if kind.fam is self.d.family: if kind.arg is self.mod.UniSet.Nothing: d = '()' else: d = self.d.ownerclassifier.get_userkindargrepr(kind.arg) return 'dictof=%s' % d else: return kind.fam.classifier.get_userkindargrepr(kind) def owners(self, X): return self.d.owners(X) class RetClaSetFamily: def __init__(self, mod, classifier): self.defrefining(mod.Use.Anything) self.classifier = classifier def c_alt(self, a, alt): return a.arg.classifier.er.refdby.classifier.get_alt(a, alt) return self.classifier.get_alt(a, alt) def _get_arg_brief(self, a): return a.arg.er.refdby.classifier.get_tabrendering(a, False) def c_get_brief(self, a): return '<referred by: %s>' % self._get_arg_brief(a) def c_get_brief_alt(self, a, alt): x = { '<': 'by less than', '<=': 'by at most', '>=': 'by at least', '>': 'by more than', }[alt] return '<referred %s: %s>' % (x, self._get_arg_brief(a)) def c_get_ckc(self, a): return self.classifier, a.arg.clikinds, '==' def c_repr(self, a): return '%r.refdby' % a.arg # Public def sokind(self, sok): if not isinstance(sok, SoKind): raise TypeError('SoKind expected') er = sok.classifier.er.refdby kinds = (self(sok),) return CallableSoKind(er, kinds) class ByRetClaSet(Classifier): def __init__(self, mod, name, rg, referrer_classifier, doc): Classifier.__init__(self, mod, name, with_referrers=True) self.rg = rg self.referrer_classifier = referrer_classifier self.family = self.mod.fam_mixin_argatom(RetClaSetFamily, self) self.__doc__ = doc def get_byname(self): return 'referrer kinds' def get_cli(self): memo = {} return self.mod.hv.cli_rcs(self.rg, self.referrer_classifier.cli, memo) def get_inverted_refkind(self, k): if k.fam.opname == 'OR': ks = k.arg elif k is self.mod.Use.Nothing: ks = () else: ks = (k,) rks = [] for k in ks: rks.append(self.referrer_classifier.get_kindarg(k)) return self.mod.ImpSet.immnodeset(rks) def get_kind(self, k): if k: return self.family(QuickSoKind(self.referrer_classifier, k)) else: return self.mod.refdbynothing def get_tabheader(self, ctx=''): th = 'Referrers by %s' % self.referrer_classifier.get_tabheader(ctx) if ctx: th = '{%s}' % th return th def get_tabrendering(self, cla, ctx): rs = [self.referrer_classifier.get_tabrendering( x, ctx) for x in cla.arg.kinds] rs.sort() r = ', '.join(rs) if ctx: r = '{%s}' % r elif not r: r = '<Nothing>' return r def get_userkind(self, args): firstsok = None clikinds = [] for arg in args: if isinstance(arg, SoKind): if not arg.classifier is self.referrer_classifier: raise ValueError('Expected a SoKind with the %r classifier, argument had %r.' % ( self.referrer_classifier.name, arg.classifier.name)) clikinds.extend(arg.clikinds) if firstsok is None: firstsok = arg else: # Assume we got a single kind # get_kindarg takes care of classifier error checking clikinds.append(self.referrer_classifier.get_kindarg(arg)) if len(args) > 1 or firstsok is None: sok = QuickSoKind(self.referrer_classifier, self.mod.ImpSet.immnodeset(clikinds)) else: sok = firstsok return self.family(sok) class InRelFamily: def __init__(self, mod, classifier): self.classifier = classifier self.defrefining(mod.Use.Anything) def _eq_args(self, a, b): # They are sequences (immnodesets) of relations. # I have not memoized them since I was afraid they would last too long # and I thought it not be worthwhile and hope this comparison is not done too often. # So I will compare them as equality based sets. a = dict([(x, ()) for x in a]) b = dict([(x, ()) for x in b]) return a == b def _ge_ATOM(self, a, b): # b is known to not be Nothing since its c_le doesn't call back if self is b.fam: return self._eq_args(a.arg, b.arg) return b.fam.supercl is not None and b.fam.supercl <= a def _le_ATOM(self, a, b): # b is known to not be Nothing since its c_ge doesn't call back if self is b.fam: return self._eq_args(a.arg, b.arg) return self.supercl is not None and self.supercl <= b def c_alt(self, a, alt): return self.classifier.get_alt(a, alt) def c_get_brief(self, a): return '<via %s>' % self.classifier.get_tabrendering(a, None) def c_repr(self, a): return '%s(%s)' % (self.classifier.get_reprname(), self.classifier.get_userkindargrepr(a)) class ByInRel(Classifier): def __init__(self, mod, name, rg): Classifier.__init__(self, mod, name, with_referrers=True) self.rg = rg self.family = mod.fam_mixin_argatom(InRelFamily, self) def _rel2str(self, r): P = self.mod._parent.Path t = P.rel_table x = t[r.kind](r.relator) s = x.stra('_', safe=False) if s.startswith('_'): s = s[1:] return s def _str2rel(self, s): # Parse a string as generated by rel2str, # to recreate the relation object. P = self.mod._parent.Path orgs = s def mkrel(R, args): return self.mod.View.heapyc.Relation(R.code, args) if s.startswith('list(_)['): s = s[8:].rstrip(']') r = int(s) rel = mkrel(P.R_INSET, r) return rel if s.startswith('_'): s = s[1:] if s.startswith('['): s = s[1:].rstrip(']') loc = {'hp': self.mod.Use} r = eval(s, loc) rel = mkrel(P.R_INDEXVAL, r) elif s.startswith('.'): s = s[1:] if s.replace('_', 'x').isalnum(): rel = mkrel(P.R_ATTRIBUTE, s) elif s.startswith('f_locals['): s = s[9:].rstrip(']') r = eval(s, {}) rel = mkrel(P.R_LOCAL_VAR, r) elif s.startswith('f_locals ['): s = s[10:].rstrip(']') r = eval(s, {}) rel = mkrel(P.R_CELL, r) elif s.startswith('keys()['): s = s[7:].rstrip(']') r = int(s) rel = mkrel(P.R_INDEXKEY, r) elif s.startswith('__dict__.keys()['): s = s[16:].rstrip(']') r = int(s) rel = mkrel(P.R_HASATTR, r) else: raise SyntaxError('Cant make a relation of %r.' % orgs) elif s.startswith('->'): s = s[2:] if s.startswith('f_valuestack['): s = s[13:].rstrip(']') r = int(s) rel = mkrel(P.R_STACK, r) else: rel = mkrel(P.R_INTERATTR, s) else: raise SyntaxError('Cant make a relation of %r.' % orgs) return rel def get_byname(self): return 'referred via' def get_cli(self): memokind = {} memorel = {} return self.mod.hv.cli_inrel(self.rg, memokind, memorel) def get_kind(self, k): return self.family(k) def get_tabheader(self, ctx=''): if not ctx: return "Referred Via:" else: r = 'Referred Via' if ctx == 'and': r = '{%s}' % r return r def get_tabrendering(self, kind, ctx=''): r = self.get_userkindargrepr(kind) if ctx == 'and': r = '{%s}' % r return r def get_userkind(self, args): return self.get_kind([self._str2rel(x) for x in args]) def get_userkindargrepr(self, kind): a = [repr(self._rel2str(x)) for x in kind.arg] a.sort() return ', '.join(a) class AndClassifier(Classifier): def __init__(self, mod, name, args): # At least 2 args if name is None: name = '(%s)' % ' & '.join([x.name for x in args]) Classifier.__init__(self, mod, name, cli=None, supers=args, depends=args) self.args = args def get_byname(self): return '<%s>' % ' & '.join([x.get_byname() for x in self.args]) def get_cli(self): memo = {} return self.mod.hv.cli_and(tuple([x.cli for x in self.args]), memo) def get_kind(self, k): ks = [] for ki, ci in zip(k, self.args): ks.append(ci.get_kind(ki)) return self.mod.UniSet.fam_And._cons(ks) def get_reprname(self): return '(%s)' % ' & '.join([x.get_reprname() for x in self.args]) def get_tabheader(self, ctx=''): r = '%s' % ' & '.join([x.get_tabheader('and') for x in self.args]) if ctx == 'and': r = '(%s)' % r return r def get_tabrendering(self, cla, ctx=''): ss = [] for a, cl in zip(cla.arg, self.args): s = cl.get_tabrendering(a, 'and') ss.append(s) r = ' & '.join(ss) if ctx == 'and': r = '(%s)' % r return r class ModuleFamily: def __init__(self, mod, classifier): self.defrefining(mod.Use.Anything) self.classifier = classifier self.range = mod.fam_Family(self) def c_contains(self, a, b): return b is a.arg def c_get_render(self, a): return self.mod.summary_str(a.arg) def c_get_brief(self, a): return self.mod.summary_str(type(a.arg))(a.arg) def c_repr(self, a): return '%s(%s)' % (self.classifier.get_reprname(), self.classifier.get_userkindargrepr(a)) class ByModule(Classifier): def __init__(self, mod, name): def classify(x): self.nc += 1 return x cli = mod.hv.cli_user_defined(mod.Use.Type.classifier.cli, mod.Use.Type.Module.arg, classify, None ) Classifier.__init__(self, mod, name, cli) self.not_module = ~mod.Use.Type.Module self.nc = 0 self.family = mod.fam_mixin_argatom(ModuleFamily, self) self.ModuleType = mod.types.ModuleType def get_byname(self): return 'module' def get_kind(self, k): if k is None: return self.not_module else: return self.family(k) def get_kindarg(self, kind): if kind is self.not_module: return None else: assert kind.fam is self.family return kind.arg def get_tabheader(self, ctx=''): return 'Module' def get_userkind(self, name=None, at=None): if name is None and at is None: return self.not_module if at is None: try: m = self.mod.View.target.sys.modules[name] except KeyError: raise ValueError( 'No module %r in View.target.sys.modules.' % name) else: m = self.mod.View.obj_at(at) if not isinstance(m, self.ModuleType): raise TypeError( 'The specified object is not of module type, but %r.' % type(m)) if name is not None and m.__name__ != name: raise ValueError( 'The specified module has not name %r but %r.' % (name, m.__name__)) return self.family(m) def get_userkindargrepr(self, kind): if kind is self.not_module: return '' else: m = kind.arg name = m.__name__ s = '%r' % name if self.mod._root.sys.modules.get(name) is not m: s += ', at=%s' % hex(id(m)) return s class AltFamily: def __init__(self, mod, altcode): if altcode not in ('<', '<=', '==', '!=', '>', '>='): raise ValueError('No such comparison symbol: %r' % altcode) self.altcode = altcode self.disjoints -= [self] def c_get_brief(self, a): return a.arg.fam.c_get_brief_alt(a.arg, self.altcode) def c_get_ckc(self, a): ckc = list(a.arg.get_ckc()) if ckc[-1] == '==': ckc[-1] = self.altcode else: raise ValueError( 'Can not make alternative kind, non-equality comparison on underlying kind.') return tuple(ckc) def c_repr(self, a): return '%s.alt(%r)' % (repr(a.arg), self.altcode) class FindexFamily: def __init__(self, mod, classifier): self.defrefining(mod.Use.Anything) self.classifier = classifier self.range = mod.fam_Family(self) def c_get_brief(self, a): if not 0 <= a.arg < len(self.classifier.kinds): return '<None>' else: return '%s / %d' % (self.classifier.kinds[a.arg].brief, a.arg) def c_repr(self, a): return '%s(%d)' % (self.classifier.get_reprname(), a.arg) class ByFindex(Classifier): def __init__(self, mod, name, kinds): self.alts = [k.fam.c_get_ckc(k) for k in kinds] depends = [ckc[0] for ckc in self.alts] Classifier.__init__(self, mod, name, depends=depends) self.kinds = kinds self.family = mod.fam_mixin_argatom(FindexFamily, self) def get_cli(self): alts = tuple([(cla.cli, k, cmp) for (cla, k, cmp) in self.alts]) memo = {} cli = self.mod.hv.cli_findex(alts, memo) return cli def get_byname(self): return 'index of first matching kind of %s' % (self.kinds,) def get_tabheader(self, ctx=''): return 'First Matching Kind / Index' class ProdFamily: def __init__(self, mod, classifier): self.defrefining(mod.Use.Anything) self.classifier = classifier self.range = mod.fam_Family(self) def c_alt(self, a, alt): return self.classifier.get_alt(a, alt) def c_get_brief(self, a): if a.arg is None: return 'unknown' else: return '%s:%d' % a.arg def c_repr(self, a): return '%s(%s)' % (self.classifier.get_reprname(), self.classifier.get_userkindargrepr(a)) class ByProd(Classifier): def __init__(self, mod, name): Classifier.__init__(self, mod, name) self.family = mod.fam_mixin_argatom(ProdFamily, self) def get_byname(self): return 'producer' def get_cli(self): self.mod.Use._check_tracemalloc() memo = {} return self.mod.hv.cli_prod(memo) def get_tabheader(self, ctx=''): return 'Producer (line of allocation)' def get_userkind(self, args, *kwds): if args and kwds: raise TypeError( '{}() takes either positional or keyword arguments'.format( self.get_reprname())) if kwds: if set(kwds.keys()) != {'filename', 'lineno'}: raise TypeError( '{}() keyword arguments must be ' '"filename" and "lineno"'.format( self.get_reprname())) return self.family((kwds['filename'], kwds['lineno'])) if len(args) == 0: return self.family(None) elif len(args) == 1: arg, = args if isinstance(arg, str): # filename return self.family((arg, None)).alt('<') filename = self.mod.inspect.getsourcefile(arg) lines, lnum = self.mod.inspect.getsourcelines(arg) lines, lnum = len(lines), max(lnum, 1) return ( self.family((filename, None)).alt('<') & self.family((None, lnum)).alt('>=') & self.family((None, lnum + lines)).alt('<')) elif len(args) == 2: filename, lineno = args if filename is not None and not isinstance(filename, str): raise TypeError( '{}() argument 1 must be string or None'.format( self.get_reprname())) if lineno is not None and not isinstance(lineno, int): raise TypeError( '{}() argument 2 must be integer or None'.format( self.get_reprname())) return self.family((filename, lineno)) else: raise TypeError( '{}() takes from 0 to 2 positional arguments ' 'but {} were given'.format( self.get_reprname(), len(args))) def get_userkindargrepr(self, kind): if kind.arg is None: return '' return '%r, %r' % kind.arg class _GLUECLAMP_: _imports_ = ( '_parent:ImpSet', '_parent:View', '_parent.View:hv', '_parent:UniSet', '_parent.UniSet:fam_mixin_argatom', '_parent:Use', '_root.guppy.etc.etc:str2int', '_root:inspect', '_root:re', '_root:types', '_root:builtins', ) def _er_by_(self, constructor, args, *kwds): return self.UniSet.fam_EquivalenceRelation(constructor, args, *kwds) # Exported equivalence relations def _get_Clodo(self): return self._er_by_(ByClassOrDictOwner, self, name='Clodo') def _get_Id(self): return self._er_by_(ByIdentity, self, name='Id') def _get_Idset(self): return self._er_by_(ByIdentitySet, self, name='Idset') def _get_Module(self): return self._er_by_(ByModule, self, name='Module') def _get_Prod(self): return self._er_by_(ByProd, self, name='Prod') def _get_Unity(self): return self._er_by_(ByUnity, self, name='Unity') def _get_Rcs(self): return self.mker_refdby(self.Clodo) def mker_and(self, ers): if len(ers) == 0: return self.Unity classifiers = [er.classifier for er in ers] name = None return self.UniSet.fam_EquivalenceRelation(AndClassifier, self, name, classifiers) def mker_dictof(self, er, name=None): if name is None: name = '%s.dictof' % er.classifier.name return self.mker_memoized( name, lambda: self._er_by_(ByDictOwner, self, name, er.classifier)) def _get_memo_er(self): return {} def mker_memoized(self, name, f): v = self.memo_er.get(name) if v is None: self.memo_er[name] = v = f() return v def mker_refdby(self, er, name=None): if name is None: name = '%s.refdby' % er.classifier.name return self.mker_memoized( name, lambda: self._er_by_( ByRetClaSet, self, name, self.View.rg, er.classifier, """%s Classify by <%s> of referrers. This classifier uses the %r classifier to classify the referrers of the object. The classifications of the referrers are collected in a set. This set becomes the classification of the object. """ % (name, er.classifier.get_byname(), er.classifier.name))) def _get_Size(self): return self._er_by_(ByIndiSize, self, 'Size') def _get_Type(self): return self._er_by_(ByType, self, 'Type') def _get_Via(self): View = self.View return self._er_by_( ByInRel, self, 'Via', View.rg) def tc_adapt(self, k): # Adapt to a type. # Accepts a type object, or a string representation # (at least as) by tc_repr. if isinstance(k, type): return k if not isinstance(k, str): raise TypeError('type, class or basestring expected') err = ("String argument to tc_adapt should be of form\n" "'<class MODULE.NAME at 0xADDR>' or\n" "'<type MODULE.NAME at 0xADDR>' or\n" "'<at 0xADDR>'. I got: %r" % k) s = k if not (s.startswith('<') and s.endswith('>')): raise ValueError(err) s = s.lstrip('<').rstrip('>') s = s.split(' ') if len(s) < 2: raise ValueError(err) t = s[0] addr = self.str2int(s[-1]) kind = self.View.obj_at(addr) if t == 'at': if len(s) != 2: raise ValueError(err) ty = None else: if len(s) != 4: raise ValueError(err) if t not in ('type', 'class'): raise ValueError(err) try: ty = getattr(self.types, t.capitalize()+'Type') except AttributeError: ty = getattr(self.builtins, t.lower()) if not isinstance(kind, ty): raise TypeError('%s object expected' % t) if not s[2] == 'at': raise ValueError(err) names = s[1].split('.') if len(names) < 2: raise ValueError(err) modulename = '.'.join(names[:-1]) tcname = names[-1] if kind.__module__ != modulename: raise ValueError( 'The %s %r has wrong __module__, expected %r.' % (t, kind, modulename)) if kind.__name__ != tcname: raise ValueError( 'The %s %r has wrong __name__, expected %r.' % (t, kind, tcname)) return kind def tc_repr(self, k): # Represent a type object as a string, # so that it can converted back via tc_adapt, # as long as it still exists in the heap. # There is no absolute guarantee that it will always become the same object, # but I hope it will work well enough in practice. # See also Notes Sep 7 2005. if isinstance(k, type): t = 'type' else: raise TypeError('type expected') return '<%s %s.%s at %s>' % (t, k.__module__, k.__name__, hex(id(k))) # Convenience interfaces def _get_alt(self): altmemo = { '==': lambda k: k, '!=': lambda k: ~k, } def alt(kind, cmp): a = altmemo.get(cmp) if a is None: a = self.fam_mixin_argatom(AltFamily, cmp) altmemo[cmp] = a return a(kind) return alt def biper(self, kind): return self.findex(kind) def _get_dictof(self): return self.fam_mixin_argatom(OwnedDictFamily) def _get_dictofnothing(self): return self.dictof(self.Use.Nothing) def _get_invtypemod(self): invtypemod = {} for k, v in list(self.types._module.__dict__.items()): if k.endswith('Type'): invtypemod[v] = k[:-4] return invtypemod def _get_notdict(self): return ~self.Use.Type.Dict def findex(self, kinds): return self._er_by_( ByFindex, self, 'findex(%s)' % ', '.join([repr(k) for k in kinds]), kinds ) def _get_refdbynothing(self): return self.sonokind.refdby def sokind(self, kinds): """sokind(0..:Kind+) -> SetOfKind """ cla = None clikinds = [] if not kinds: raise ValueError('At least one argument must be given.') for kind in kinds: ckc = kind.get_ckc() if cla is None: cla = ckc[0] else: if ckc[0] is not cla: raise ValueError( 'Kind at index %d has wrong classifier.' % len(clikinds)) if ckc[-1] != '==': raise ValueError( 'Kind at index %d has wrong comparision.' % len(clikinds)) clikinds.append(ckc[1]) return QuickSoKind(cla, self.ImpSet.immnodeset(clikinds)) def _get_sonokind(self): return SoNoKind(self.Unity, ())	45.16 KB	2026-01-20 12:58
📄 Console.py import code class Console(code.InteractiveConsole): EOF_key_sequence = '-' def __init__(self, stdin, stdout, locals=None, filename="<console>"): self.stdin = stdin self.stdout = stdout code.InteractiveConsole.__init__(self, locals, filename) def raw_input(self, prompt=""): """Write a prompt and read a line. The returned line does not include the trailing newline. When the user enters the EOF key sequence, EOFError is raised. """ self.write(prompt) line = self.stdin.readline() if not line: raise EOFError line = line.rstrip() if line == self.EOF_key_sequence: raise EOFError else: return line def write(self, data): self.stdout.write(data) self.stdout.flush()	843 B	2026-01-20 12:58
📄 Doc.py class Doc: # base class def __mod__(self, other): other = self.mod.getdoc(other) return self.mapchildren(lambda x: x % other) def __rmod__(self, other): return self.mod.getdoc(other) % self def __str__(self): return self.getstr() def __eq__(self, other): if not isinstance(other, self.__class__): return 0 return str(self) == str(other) def __hash__(self): return hash(str(self)) def shortest(self): return self.mapchildren(lambda x: x.shortest()) class Anon(Doc): def __init__(self, mod, obj): self.mod = mod self.obj = obj def getstr(self): return repr(self.obj) def mapchildren(self, f): return self class Source(Doc): def __init__(self, mod, text): self.mod = mod self.text = text def getstr(self): return self.text def mapchildren(self, f): return self class Attribute(Doc): def __init__(self, mod, obj, name): self.mod = mod self.obj = obj self.name = name def __mod__(self, other): if self.obj is other: return self.mod.rootattribute(other, self.name) return self.mapchildren(lambda x: x % other) def getstr(self): return '%s.%s' % (self.obj.getstr(), self.name) def mapchildren(self, f): return self.__class__(self.mod, f(self.obj), self.name) class RootAttribute(Doc): def __init__(self, mod, obj, name): self.mod = mod self.obj = obj self.name = name def getstr(self): return '%s' % (self.name,) def mapchildren(self, f): return self class BinaryOp(Doc): table = { 'and': '&', 'or': '\|', 'sub': '-', 'mul': '', 'pow': '', 'lshift': '<<', 'rshift': '>>', } def __init__(self, mod, op, a, b): self.mod = mod self.op = op self.a = a self.b = b def getstr(self): return '%s %s %s' % (self.a.getstr(), self.table[self.op], self.b.getstr()) def mapchildren(self, f): return self.__class__(self.mod, self.op, f(self.a), f(self.b)) class UnaryOp(Doc): table = { 'invert': '~', 'neg': '-', 'pos': '+', } def __init__(self, mod, op, a): self.mod = mod self.op = op self.a = a def getstr(self): return '%s %s' % (self.table[self.op], self.a.getstr()) def mapchildren(self, f): return self.__class__(self.mod, self.op, f(self.a)) class CallFunc(Doc): def __init__(self, mod, obj, args, *kwds): self.mod = mod self.obj = obj self.args = args self.kwds = kwds def getstr(self): return '%s(%s%s)' % ( self.obj.getstr(), ', '.join([x.getstr() for x in self.args]), ', '.join(['%s=%s' % (k, v.getstr()) for k, v in list(self.kwds.items())])) def mapchildren(self, f): obj = f(self.obj) args = [f(a) for a in self.args] kwds = dict([(k, f(v)) for (k, v) in list(self.kwds.items())]) return self.__class__(self.mod, obj, args, *kwds) class Multi(Doc): def __init__(self, mod, set): self.mod = mod self.str = '{%s}' % ', '.join([x.getstr() for x in set]) self.set = set def getstr(self): return self.str def mapchildren(self, f): return self.__class__(self.mod, dict([(f(x), 1) for x in self.set])) def shortest(self): ls = None for a in self.set: a = a.shortest() l = len(a.getstr()) if ls is None or l < ls: ls = l st = a return st class Root(Doc): def __init__(self, mod, name='<root>'): self.mod = mod self.name = name def __call__(self, name): return self.__class__(self.mod, name) def mapchildren(self, f): return self def getstr(self): return self.name class Tuple(Doc): def __init__(self, mod, args): self.mod = mod self.args = args def mapchildren(self, f): return self.__class__(self.mod, [f(x) for x in self.args]) def getstr(self): x = '(%s)' % ', '.join([x.getstr() for x in self.args]) if len(self.args) == 1: x = x[:-1]+',)' return x class DocError(Exception): pass class _GLUECLAMP_: def add_origin(self, obj, origin): o = getattr(obj, '_origin_', None) if o is None: obj._origin_ = origin else: obj._origin_ = self.multi(o, origin) return obj def add_wrapdict(self, obj, doc): wd = self.wrapdict o = wd.get(id(obj)) if o is None: o = (obj, doc) else: o = (obj, self.multi(o[1], doc)) wd[id(obj)] = o return obj def anon(self, obj): return Anon(self, obj) def attribute(self, obj, name): return Attribute(self, self.getdoc(obj), name) def binop(self, op, a, b): return BinaryOp(self, op, self.getdoc(a), self.getdoc(b)) def callfunc(self, obj, args, *kwds): getdoc = self.getdoc obj = getdoc(obj) args = [getdoc(a) for a in args] kwds = dict([(k, getdoc(v)) for (k, v) in list(kwds.items())]) return CallFunc(self, obj, args, *kwds) def getdoc(self, obj): if isinstance(obj, Doc): return obj w = getattr(obj, '_origin_', None) if isinstance(w, Doc): return w w = self.wrapdict.get(id(obj)) if w is not None: return w[1] if isinstance(obj, tuple): return self.tuple(obj) return self.anon(obj) def multi(self, a, b): a = self.getdoc(a) b = self.getdoc(b) if isinstance(a, Multi): set = a.set.copy() if len(set) > 4: return a else: set = {a: 1} if isinstance(b, Multi): set.update(b.set) else: set[b] = 1 return Multi(self, set) def _get_root(self): return Root(self) def rootattribute(self, root, name): return RootAttribute(self, self.getdoc(root), name) def source(self, text): return Source(self, text) def tuple(self, args): return Tuple(self, [self.getdoc(x) for x in args]) def unop(self, op, a): return UnaryOp(self, op, self.getdoc(a)) def wrap(self, obj, doc): assert obj is not self._parent.UniSet.UniSet w = getattr(obj, '_derive_origin_', None) if w is not None: if getattr(w, 'im_self', None) is obj or isinstance(w, self._root.types.MethodType): obj = w(doc) elif w == 'ADD': obj = self.add_origin(obj, doc) else: raise DocError( "Doc.wrap: attribute '_derive_origin_' has invalid value") elif isinstance(obj, self._root.types.MethodType): obj = self.wrap_method(obj, doc) elif isinstance(obj, self._root.types.FunctionType): obj = self.wrap_function(obj, doc) else: obj = self.add_wrapdict(obj, doc) return obj def _get_wrapdict(self): return {} def wrap_function(mod, obj, doc): def f(args, kwds): r = obj(args, *kwds) r = mod.wrap(r, mod.callfunc(doc, args, *kwds)) return r f._origin_ = doc return f def wrap_method(mod, obj, doc): im_func = obj.__func__ def f(self, args, *kwds): r = im_func(self, args, *kwds) r = mod.wrap(r, mod.callfunc(doc, args, **kwds)) return r return mod._root.types.MethodType(f, obj.__self__)	7.81 KB	2026-01-20 12:58
📄 ImpSet.py class _GLUECLAMP_: _imports_ = ( '_parent.UniSet:IdentitySetMulti', '_parent.UniSet:IdentitySet', '_parent.View:_hiding_tag_', '_root.guppy:sets', '_root.guppy.sets:NodeSet', '_root.guppy.sets:ImmNodeSet', '_root.guppy.sets:MutNodeSet', '_root.guppy.sets:immbit', '_root.guppy.sets:immbitrange', '_root.guppy.sets:immbitset', '_root.guppy.sets:mutbitset', ) def _get_emptynodeset(self): return self.immnodeset() def immnodeset(self, it=()): return self.sets.immnodeset(it, self._hiding_tag_) def immnodeset_union(self, sets): return self.sets.immnodeset_union(sets, self._hiding_tag_) def mutnodeset(self, args, kwds): s = self.sets.mutnodeset(args, **kwds) s._hiding_tag_ = self._hiding_tag_ return s	870 B	2026-01-20 12:58
📄 Monitor.py import os import pprint import signal import socket import socketserver import sys import threading import time import traceback import pickle as pickle try: import readline # Imported to _enable_ command line editing except ImportError: pass import select import queue from guppy.heapy.RemoteConstants import * from guppy.heapy.Console import Console from guppy.sets import mutnodeset from guppy.etc.etc import ptable from guppy.etc import cmd class Server(socketserver.ThreadingTCPServer): pass def ioready(fd, wait): r, w, x = select.select([fd], [], [], wait) return len(r) def queue_get_interruptible(q, noblock=0): while 1: try: return q.get(timeout=0.2) except queue.Empty: if noblock: break # Special value signals that connection has been closed CONN_CLOSED = ('CLOSED',) class Handler(socketserver.StreamRequestHandler): allow_reuse_address = 1 def close(self): if not self.isclosed.tas(0): self.server.monitor.remove_connection(self) self.dataq.put(CONN_CLOSED) self.request.shutdown(2) self.request.close() def send_cmd(self, cmd): if not cmd.endswith('\n'): cmd += '\n' self.request.send(cmd.encode('utf-8')) def browser_cmd(self, cmd): if self.prompt == '>>> ': self.exec_cmd('q', retdata=1) if self.prompt == '<Annex> ': self.exec_cmd('cont', retdata=1) return self.exec_cmd(cmd, retdata=1) def exec_cmd(self, cmd, retdata=0, noblock=0): if cmd is not None: self.send_cmd(cmd) self.promptstate = False datas = [] while 1: p = queue_get_interruptible(self.dataq, noblock) if p is None: if self.promptstate: break else: time.sleep(1) continue if p is CONN_CLOSED: raise EOFError if p[0] == 'DATA': self.promptstate = False if retdata: datas.append(p[1]) else: sys.stdout.write(p[1]) elif p[0] == 'PROMPT': self.prompt = p[1] if self.dataq.empty(): self.promptstate = True break else: self.promptstate = False else: assert 0 if retdata: return ''.join(datas) def get_ps(self, name): for line in self.firstdata.split('\n'): if line.startswith(name): if '=' in line: ix = line.index('=') line = line[ix+1:].strip() return line return '' def get_val(self, expr): data = self.browser_cmd('dump %s' % expr) return pickle.loads(data) def handle(self): self.prompt = None self.promptstate = False self.isclosed = mutnodeset() self.dataq = queue.Queue() self.server.monitor.add_connection(self) while 1: try: data = self.rfile.readline().decode('utf-8') if not data: raise EOFError('End of file') if data.endswith(DONE): raise EOFError('DONE') except (EOFError, socket.error): break if data.endswith(READLINE): prompt = data[:-len(READLINE)] self.dataq.put(('PROMPT', prompt)) if self.prompt is None: self.firstdata = self.exec_cmd(cmd=None, retdata=1) else: self.dataq.put(('DATA', data)) self.close() class MonitorConnection(cmd.Cmd): use_raw_input = 1 def __init__(self, monitor): self.aliases = {} cmd.Cmd.__init__(self) self.hno = 0 self.isclosed = 0 self.forceexit = 0 self.prompt = '<Monitor> ' self.monitor = monitor self.server = s = Server((LOCALHOST, HEAPYPORT), Handler) self.server.monitor = monitor self.st = threading.Thread(target=self.run_server, args=()) self.st.start() def close(self): self.isclosed = 1 self.server.socket.shutdown(2) self.server.server_close() self.server.verify_request = lambda x, y: 0 def default(self, line): cmd.Cmd.default(self, line) cmd.Cmd.do_help(self, '') def run_server(self): s = self.server while not self.isclosed: s.handle_request() s.server_close() def exec_cmd(self, cmd): if not cmd: # I don't want the repeat of previous command when giving # empty command that is provided by cmd.py. # It turned out to be confusing sometimes. return line = cmd try: line = self.precmd(line) stop = self.onecmd(line) stop = self.postcmd(stop, line) return stop except BaseException: self.handle_error(line) def handle_error(self, cmdline): """Handle an error gracefully. May be overridden. The default is to print a traceback and continue. """ print('-'40, file=sys.stderr) print('Exception happened during processing the command', end=' ', file=sys.stderr) print(repr(cmdline), file=sys.stderr) import traceback traceback.print_exc() print('-'40, file=sys.stderr) # Alias handling etc copied from pdb.py in Python dist def precmd(self, line): """Handle alias expansion and ';;' separator.""" self.curline = line if not line: return line args = line.split() while args[0] in self.aliases: line = self.aliases[args[0]] if '%' in line: ii = 1 for tmpArg in args[1:]: line = line.replace("%" + str(ii), tmpArg) line = line.replace('%>=' + str(ii), ' '.join(args[ii:])) ii = ii + 1 line = line.replace("%", ' '.join(args[1:])) else: line = line + ' ' + ' '.join(args[1:]) args = line.split() # split into ';;' separated commands # unless it's an alias command if args[0] != 'alias': marker = line.find(';;') if marker >= 0: # queue up everything after marker next = line[marker+2:].lstrip() self.cmdqueue.append(next) line = line[:marker].rstrip() return line def do_exit(self, arg): self.forceexit = 1 return 1 def help_exit(self): print("""exit ----- Exit from the monitor and from the Python process that started it. This makes sure to exit without waiting for the server thread to terminate. See also the q command.""") do_h = cmd.Cmd.do_help def help_h(self): print("""h(elp) ----- Without argument, print the list of available commands. With a command name as argument, print help about that command.""") def help_help(self): self.help_h() def do_int(self, arg): try: con = Console(stdin=self.stdin, stdout=self.stdout, locals=self.__dict__) con.interact( "Local interactive console. To return to Monitor, type %r." % con.EOF_key_sequence) finally: pass def help_int(self): print("""int ----- Local interactive console. This will bring up a Python console locally in the same interpreter process that the Monitor itself.""") def do_ki(self, arg): if not arg: arg = self.conid arg = int(arg) c = self.monitor.connections[arg] if c.get_ps('noninterruptible'): print('''\ Error: Can not interrupt this remote connection (uses Python < 2.4)''') else: print('Sending KeyboardInterrupt to connection %s.' % arg) c.send_cmd(KEYBOARDINTERRUPT) def help_ki(self): print("""ki <connection ID> ----- Keyboard Interrupt Send a command to interrupt the remote thread on the specified connection (default is the last one connected to). Notes: It currently only works with Python >= 2.4. The remote thread will not always be awakened, for example if it is waiting in time.sleep(). Sometimes using several ki commands helps.""") def do_lc(self, arg): table = [['CID', 'PID', 'ARGV']] for cid, con in list(self.monitor.connections.items()): table.append([cid, con.get_ps('target.pid'), con.get_ps('target.sys.argv')]) ptable(table, self.stdout) def help_lc(self): print("""lc ----- List Connections. List the currently open connections. The table printed has one line per connection in this form: CID PID ARGV 1 17999 ['/home/nilsson/bin/solitaire.py'] CID is the connection ID, which may be used as argument to the sc command. PID is the process ID of the target interpreter process. In Linux, this is the parent of the remote control interpreter thread that runs the Annex that the connection is talking to. ARGV is the argument vector in the target Python interpereter.""") def do_sc(self, arg): if arg: self.conid = int(arg) print('Remote connection %d. To return to Monitor, type <Ctrl-C> or .<RETURN>' % self.conid) self.monitor.set_connection(self.monitor.connections[self.conid]) def help_sc(self): print("""sc <connection ID> ----- Set connection to communicate with a remote thread. With an argument, set current connection to the number specified. Without argument, use the same connection as last time. You will then be talking to a remote process via that connection. You can return to Monitor at any time by <Ctrl-C>. You may also use the '.' command (followed by <Return>), if the remote process is waiting for input. The '.' character may be followed by a monitor command, to execute it directly instead of returning to the monitor. For example, when talking to a connection, '.sc 1' will directly change to connection 1.""") def do_q(self, arg): return 1 def help_q(self): print("""q ----- Quit from the monitor. This will not exit from Python itself if called from an interactive interpreter. To make sure to exit from Python, use the exit command.""") class Monitor: use_raw_input = 1 def __init__(self): self.connection = self.monitor_connection = MonitorConnection(self) self.connections = {} self.ids = 0 self.prompt = None def newid(self): if not self.connections: self.ids = 1 self.monitor_connection.conid = self.ids else: self.ids = max([1]+[c for c in list(self.connections.keys())])+1 return self.ids def add_connection(self, connection): hid = self.newid() self.connections[hid] = connection connection.monitor_id = hid self.print_async(' Connection %s opened ' % hid) def print_async(self, text): """ Print text only if we are waiting for input, and then restore the prompt. """ if self.prompt is not None: print('\n'+text) sys.stdout.write(self.prompt) sys.stdout.flush() def remove_connection(self, connection): del self.connections[connection.monitor_id] if connection is self.connection: self.set_connection(self.monitor_connection) self.print_async(' Connection %s closed ' % connection.monitor_id) def run(self): try: stop = 0 while not stop: try: while not stop: conn = self.connection self.prompt = conn.prompt if conn is not self.monitor_connection: conn.exec_cmd(cmd=None, noblock=1) cmd = input(conn.prompt) self.prompt = None conn = None if cmd.startswith('.'): if cmd == '.': self.connection = self.monitor_connection else: cmd = cmd[1:] conn = self.monitor_connection # elif cmd or self.connection is self.monitor_connection: else: conn = self.connection if conn: try: r = conn.exec_cmd(cmd) except EOFError: r = 1 if conn is self.monitor_connection and r: stop = 1 except EOFError: 'We better exit in case the input is from a file' print(' End Of File - Exiting Monitor *') self.connection = self.monitor_connection stop = 1 except KeyboardInterrupt: print('KeyboardInterrupt') print('Use the ki command to interrupt a remote process.') self.connection = self.monitor_connection continue finally: self.prompt = None # Avoid closing messages self.close() def close(self): for c in list(self.connections.values()): try: c.close() except socket.error: pass try: self.monitor_connection.close() except socket.error: pass if self.monitor_connection.forceexit: os._exit(0) def set_connection(self, connection): self.connection = connection self.prompt = connection.prompt def monitor(): """monitor() [0] Start an interactive remote monitor. This can be used to get information about the state, in particular the memory usage, of separately running Python processes. References [0] heapy_Use.html#heapykinds.Use.monitor""" from guppy.heapy import Remote Remote.off() m = Monitor() m.run() if __name__ == '__main__': monitor()	14.5 KB	2026-01-20 12:58
📄 OutputHandling.py import types import weakref # To restore the old-style class behavior that __getattr__ also affects special # methods. class _AttrProxy: _oh_proxied_classes = weakref.WeakSet({type, object}) # Don'r rely on _oh_add_proxy_attr to prime us, some clients use # setup_printing to setup __repr__ function. def __repr__(self): return self.__getattr__('__repr__')() @classmethod def _oh_add_proxy_attr(cls, attr): if not attr.startswith('__') or not attr.endswith('__'): return for scls in cls.__mro__: if scls is object: break if attr in scls.__dict__: return if attr in ('__new__', '__init__', '__getattr__', '__getattribute__', '__setattr__', '__delattr__', '__str__', ): return def closure(attr): def generated_function(self, args, kwds): func = self.__getattr__(attr) return func(args, kwds) return generated_function setattr(cls, attr, closure(attr)) @classmethod def _oh_add_proxy_class(cls, base): if base in cls._oh_proxied_classes: return for scls in base.__mro__: cls._oh_proxied_classes.add(scls) for attr, val in scls.__dict__.items(): if not isinstance(val, types.FunctionType): continue cls._oh_add_proxy_attr(attr) class OutputHandler: def __init__(self, mod, output_file): self.mod = mod self.output_file = output_file class OutputBuffer: def __init__(self, mod, opts=None): self.mod = mod self.strio = mod._root.io.StringIO() if opts is None: opts = {} self.opts = opts self.lines = [''] self.line_no = 0 def getopt(self, opt): return self.opts.get(opt) def getvalue(self): return '\n'.join(self.lines) def new_line(self): self.line_no += 1 self.lines.append('') def write(self, s): lines = s.split('\n') for line in lines[:-1]: self.write_seg(line) self.new_line() self.write_seg(lines[-1]) def write_seg(self, s): self.lines[self.line_no] += s class AllPrinter(_AttrProxy): _oh_next_lineno = None def __init__(self, printer): self._oh_printer = printer self._hiding_tag_ = printer._hiding_tag_ def __getattr__(self, attr): return self._oh_printer.getattr(self, attr) def __repr__(self): return self._oh_printer.get_str(self, True) def _oh_get_next_lineno(self): return 0 def _oh_get_start_lineno(self): return 0 def _oh_get_max_lines(self, max_lines): return None class MorePrinter(_AttrProxy): _oh_next_lineno = None def __init__(self, printer, previous): self._oh_printer = printer self._oh_previous = previous self._hiding_tag_ = printer._hiding_tag_ def __getattr__(self, attr): return self._oh_printer.getattr(self, attr) def _oh_get_next_lineno(self): next_lineno = self._oh_next_lineno if next_lineno is None: repr(self) next_lineno = self._oh_next_lineno return next_lineno def _oh_get_start_lineno(self): return self._oh_previous._oh_get_next_lineno() def _oh_get_max_lines(self, max_lines): return max_lines class Printer: def __init__(self, mod, client, handler, get_line_iter=None, max_more_lines=None, get_num_lines=None, get_label=None, get_row_header=None, get_more_msg=None, get_more_state_msg=None, get_empty_msg=None, stop_only_when_told=None ): try: handler = handler.printer.handler except AttributeError: pass if get_line_iter is None: get_line_iter = handler._oh_get_line_iter if max_more_lines is None: max_more_lines = mod.max_more_lines self.mod = mod self._hiding_tag_ = mod._hiding_tag_ self.client = client self.handler = handler self.get_line_iter = get_line_iter self.max_more_lines = max_more_lines if get_num_lines is None: get_num_lines = getattr( handler, '_oh_get_num_lines', None) if get_num_lines is not None: self.get_num_lines = get_num_lines if get_label is None: get_label = getattr( handler, '_oh_get_label', None) if get_label is not None: self.get_label = get_label if get_row_header is None: get_row_header = getattr( handler, '_oh_get_row_header', None) if get_row_header is not None: self.get_row_header = get_row_header if get_more_msg is None: get_more_msg = getattr( handler, '_oh_get_more_msg', None) if get_more_msg is not None: self.get_more_msg = get_more_msg if get_more_state_msg is None: get_more_state_msg = getattr( handler, '_oh_get_more_state_msg', None) if get_more_state_msg is not None: self.get_more_state_msg = get_more_state_msg if get_empty_msg is None: get_empty_msg = getattr( handler, '_oh_get_empty_msg', None) if get_empty_msg is not None: self.get_empty_msg = get_empty_msg self.stop_only_when_told = stop_only_when_told self.reset() def getattr(self, mp, attr): try: g = getattr(self, '_get_'+attr) except AttributeError: return getattr(self.client, attr) else: return g(mp) def line_at(self, idx): while idx >= len(self.lines_seen): try: li = next(self.line_iter) except StopIteration: raise IndexError else: if isinstance(li, tuple): cmd, line = li if cmd == 'STOP_AFTER': self.stop_linenos[len(self.lines_seen)] = 1 else: line = li self.lines_seen.append(line) return self.lines_seen[idx] def lines_from(self, idx=0): line_iter = self.line_iter if line_iter is None: line_iter = self.line_iter = self.get_line_iter() while 1: try: yield self.line_at(idx) except IndexError: return idx += 1 def _get_more(self, mp): return MorePrinter(self, mp) def _get_all(self, mp): return AllPrinter(self) def _oh_get_next_lineno(self): next_lineno = getattr(self, '_oh_next_lineno', None) if next_lineno is None: self.get_str_of_top() next_lineno = self._oh_next_lineno return next_lineno def _get_prev(self, mp): return mp._oh_previous def _oh_get_start_lineno(self): return 0 def _oh_get_max_lines(self, max_lines): return max_lines def _get_top(self, mp): return self.client def _get___repr__(self, mp): return lambda: self.get_str(mp, False) def get_label(self): return None def get_row_header(self): return None def get_str_of_top(self): return self.get_str(self, True) def get_more_state_msg(self, start_lineno, end_lineno): num_lines = self.get_num_lines() if num_lines is None: of_num_lines = '' else: of_num_lines = ' of %d' % num_lines return "Lines %d..%d%s. " % (start_lineno, end_lineno, of_num_lines) def get_more_msg(self, start_lineno, end_lineno): state_msg = self.get_more_state_msg(start_lineno, end_lineno) return "<%sType e.g. '_.more' for more.>" % (state_msg) def get_empty_msg(self): return None def get_num_lines(self): return None def get_str(self, printer, is_top): def f(): _hiding_tag_ = printer._hiding_tag_ start_lineno = printer._oh_get_start_lineno() m_max_lines = printer._oh_get_max_lines(self.max_more_lines) ob = self.mod.output_buffer() it = self.lines_from(start_lineno) if is_top: msg = self.get_label() if msg is not None: print(msg, file=ob) printer._oh_next_lineno = start_lineno try: nxt = next(it) except StopIteration: msg = self.get_empty_msg() if msg is not None: print(msg, file=ob) printer._oh_next_lineno = start_lineno else: msg = self.get_row_header() if msg is not None: print(msg, file=ob) it = self.mod.itertools.chain((nxt,), it) numlines = 0 lineno = start_lineno for line in it: if (m_max_lines is not None and numlines >= m_max_lines and ((not self.stop_only_when_told) or self.stop_linenos.get(lineno-1))): try: self.line_at(lineno+1) except IndexError: print(line, file=ob) lineno += 1 break else: print(self.get_more_msg(start_lineno, lineno-1), file=ob) break numlines += 1 print(line, file=ob) lineno += 1 printer._oh_next_lineno = lineno return ob.getvalue().rstrip() return self.mod.View.enter(lambda: f()) def reset(self): self.lines_seen = [] self.stop_linenos = {} self.line_iter = None class _GLUECLAMP_: _chgable_ = 'output_file', 'max_more_lines', _preload_ = ('_hiding_tag_',) _imports_ = ( '_parent:View', '_root:itertools', ) max_more_lines = 10 def _get__hiding_tag_(self): return self._parent.View._hiding_tag_ def _get_output_file(self): return self._root.sys.stdout def more_printer(self, client, handler=None, kwds): if handler is None: handler = client printer = Printer(self, client, handler, kwds) _AttrProxy._oh_add_proxy_class(client.__class__) return MorePrinter(printer, printer) def output_buffer(self): return OutputBuffer(self) def output_handler(self, output_file=None): if output_file is None: output_file = self.output_file return OutputHandler(self, output_file) def setup_printing(self, client, handler=None, kwds): if handler is None: handler = client more = self.more_printer(client, handler, **kwds) printer = more._oh_printer client.more = more client.all = more.all client.printer = printer def reprfunc(self): return self.printer.get_str_of_top() # Don't recreate, messes with relheap, and this is not # under _hiding_tag_ cls = client.__class__ if '__repr__' not in cls.__dict__: cls.__repr__ = reprfunc def _get_stdout(self): return self._root.sys.stdout	11.52 KB	2026-01-20 12:58
📄 Part.py class Format(object): __slots__ = 'impl', 'mod' def __init__(self, impl): self.impl = impl self.mod = impl.mod def get_formatted_row(self, row): fr = self.get_stat_data(row) rows = [] rs = row.name.split('\n') subsequent_indent = len(fr)' ' rows.extend(self.mod.wrap( fr+rs[0], width=self.mod.line_length, subsequent_indent=subsequent_indent)) for r in rs[1:]: rows.extend(self.mod.wrap( r, width=self.mod.line_length, initial_indent=subsequent_indent, subsequent_indent=subsequent_indent)) return '\n'.join(rows) def load_statrow_csk(self, r): impl = self.impl count, size, kind = r.split(' ', 2) count = int(count) size = int(size) impl.cum_size += size return StatRow(count, size, kind, impl.cur_index, impl.cum_size) def load_statrow_sk(self, r): impl = self.impl size, kind = r.split(' ', 1) size = int(size) impl.cum_size += size return StatRow(1, size, kind, impl.cur_index, impl.cum_size) def _oh_get_num_lines(self): return self.impl.numrows def _oh_get_label(self): return self.get_label() def _oh_get_row_header(self): impl = self.impl if not (impl.count or impl.size): return '' sh = self.get_stat_header() return self.mod.fill( sh + self.impl.kindheader, width=self.mod.line_length, subsequent_indent=' 'len(sh)) def _oh_get_more_msg(self, start_lineno, end_lineno): nummore = self.impl.numrows-(end_lineno+1) return "<%d more rows. Type e.g. '_.more' to view.>" % nummore def _oh_get_line_iter(self): for numrows, row in enumerate(self.impl.get_rows()): yield self.get_formatted_row(row) class SetFormat(Format): __slots__ = () def get_label(self): impl = self.impl if impl.count != 1: s = 's' else: s = '' return 'Partition of a set of %d object%s. Total size = %d bytes.' % ( impl.count, s, impl.size) def get_rowdata(self, row): return '%d %d %s' % (row.count, row.size, row.name) def get_stat_header(self): return ( ' Index Count % Size % Cumulative % ') def get_stat_data(self, row): format = '%6d %6d %3d %8d %3d %9d %3d ' impl = self.impl fr = format % ( row.index, row.count, int('%.0f' % (row.count * 100.0/impl.count)), row.size, int('%.0f' % (row.size * 100.0/impl.size)), row.cumulsize, int('%.0f' % (row.cumulsize * 100.0/impl.size)), ) return fr def load_statrow(self, r): return self.load_statrow_csk(r) class IdFormat(Format): __slots__ = () def get_label(self): impl = self.impl if impl.count != 1: s = 's' else: s = '' return ( 'Set of %d %s object%s. Total size = %d bytes.' % ( impl.count, impl.kindname, s, impl.size)) return part def get_rowdata(self, row): return '%d %s' % (row.size, row.name) def get_stat_header(self): return ( ' Index Size % Cumulative % ') def get_stat_data(self, row): impl = self.impl format = '%6d %8d %5.1f %9d %5.1f ' fr = format % ( row.index, row.size, (row.size * 100.0/impl.size), row.cumulsize, row.cumulsize * 100.0/impl.size, ) return fr def load_statrow(self, r): return self.load_statrow_sk(r) class DiffFormat(Format): __slots__ = () def _percent_of_b(self, size): if self.impl.b_size != 0: return '%9.3g' % (size100.0/self.impl.b_size,) else: return ' (n.a.)' def get_label(self): impl = self.impl x = ( 'Summary of difference operation (A-B).\n' + ' Count Size\n' + ' A %6d %8d\n' % (impl.count+impl.b_count, impl.size+impl.b_size) + ' B %6d %8d\n' % (impl.b_count, impl.b_size) + ' A-B %6d %8d = %s %% of B\n' % (impl.count, impl.size, self._percent_of_b(impl.size))) if impl.count or impl.size: x += '\nDifferences by kind, largest absolute size diffs first.' return x def get_rowdata(self, row): return '%d %d %s' % (row.count, row.size, row.name) def get_stat_header(self): return ( ' Index Count Size Cumulative % of B ') def get_stat_data(self, row): impl = self.impl format = '%6d %6d %8d %9d %s ' fr = format % ( row.index, row.count, row.size, row.cumulsize, self._percent_of_b(row.cumulsize), ) return fr def load_statrow(self, r): return self.load_statrow_csk(r) class StatRow(object): __slots__ = 'count', 'size', 'name', 'index', 'cumulsize' def __init__(self, count, size, name, index=None, cumulsize=None): self.count = count self.size = size self.name = name self.index = index self.cumulsize = cumulsize class PartRow(StatRow): __slots__ = 'set', 'kind' def __init__(self, count, size, name, index, cumulsize, set, kind): self.count = count self.size = size self.name = name self.index = index self.cumulsize = cumulsize self.set = set self.kind = kind class Stat: def __init__(self, mod, get_trows, firstheader=''): self.mod = mod self._hiding_tag_ = mod._hiding_tag_ self.get_trows = get_trows self.firstheader = firstheader self.it = iter(get_trows()) self.cur_index = 0 self.cum_size = 0 self.rows = [] r = self.get_next() while r and not r.startswith('.r:'): name = r[1:r.index(':')] value = r[r.index(':')+1:].strip() try: value = int(value) except ValueError: pass setattr(self, name, value) r = self.get_next() self.format_name = self.format self.format_class = getattr(self.mod, self.format) self.format = self.format_class(self) self.timemade = float(self.timemade) self.mod.OutputHandling.setup_printing(self, self.format) def __getitem__(self, idx): if isinstance(idx, int): if idx < 0: idx = self.numrows + idx if not (0 <= idx < self.numrows): raise IndexError('Stat index out of range.') rows = [self.get_row(idx)] elif isinstance(idx, slice): start, stop, step = idx.indices(self.numrows) rows = [self.get_row(idx) for idx in range(start, stop, step)] else: raise IndexError('Stat indices must be integers or slices.') count = 0 size = 0 for r in rows: count += r.count size += r.size trows = [ '.loader: _load_stat', '.format: %s' % self.format_name, '.timemade: %f' % self.timemade, '.count: %d' % count, '.size: %d' % size, '.kindheader: %s' % self.kindheader, '.kindname: %s' % self.kindname, '.numrows: %d' % len(rows), ] if getattr(self, 'b_count', None) is not None: trows.append('.b_count: %d' % self.b_count) trows.append('.b_size: %d' % self.b_size) for r in rows: trows.append('.r: %s' % self.format.get_rowdata(r)) return self.mod.load(trows) def __len__(self): return self.numrows def __sub__(self, other): if not isinstance(other, Stat): raise TypeError( 'Can only take difference with other Stat instance.') if self.kindheader != other.kindheader: raise ValueError('Mismatching table kind header, %r vs %r.' % ( self.kindheader, other.kindheader)) rows = [] otab = {} stab = {} for r in other.get_rows(): o = otab.get(r.name) if o: otab[r.name] = StatRow( r.count+o.count, r.size+o.size, r.name, o.index, None) else: otab[r.name] = r for r in self.get_rows(): o = otab.get(r.name) if o: del otab[r.name] count = r.count - o.count size = r.size - o.size else: count = r.count size = r.size if count == 0 and size == 0: continue sr = stab.get(r.name) if sr: sr.count += count sr.size += size else: sr = StatRow(count, size, r.name) stab[sr.name] = sr rows.append(sr) rs = list(otab.values()) rs.sort(key=lambda x: x.index) # Preserve orig. order for r in rs: sr = StatRow(-r.count, -r.size, r.name) assert sr.name not in stab rows.append(sr) rows.sort(key=lambda x: abs(x.size), reverse=True) cumulcount = 0 cumulsize = 0 for r in rows: cumulcount += r.count cumulsize += r.size r.cumulsize = cumulsize trows = [ '.loader: _load_stat', '.format: DiffFormat', '.timemade: %f' % self.mod.time.time(), '.b_count: %d' % other.count, '.b_size: %d' % other.size, '.count: %d' % cumulcount, '.size: %d' % cumulsize, '.kindheader: %s' % self.kindheader, '.kindname: %s' % self.kindname, '.numrows: %d' % len(rows), ] for r in rows: trows.append('.r: %d %d %s' % (r.count, r.size, r.name)) return self.mod.load(trows) def dump(self, fn, mode='a'): if not hasattr(fn, 'write'): f = open(fn, mode) else: f = fn try: for r in self.get_trows(): if not r[-1:] == '\n': r += '\n' f.write(r) end = '.end: .loader: %s\n' % self.loader if r != end: f.write(end) finally: if f is not fn: f.close() def get_next(self): try: r = next(self.it) except StopIteration: r = None else: r = r.rstrip('\n') self.last = r return r def get_row(self, idx): while idx >= len(self.rows): self.parse_next_row() return self.rows[idx] def get_rows(self, idx=0): while idx < self.numrows: try: row = self.get_row(idx) except IndexError: return else: yield row idx += 1 def get_rows_of_kinds(self, kinds): # Return the rows with names in sequence kinds of unique names # in that order. None if no such kind. kindtab = {} N = len(kinds) res = [None] len(kinds) for i, kind in enumerate(kinds): kindtab[kind] = i assert len(kindtab) == N n = 0 for row in self.get_rows(): idx = kindtab.get(row.name) if idx is not None: res[idx] = row n += 1 if n >= N: break return res def get_rows_n_and_other(self, N, sortby='Size'): # Get N rows, the largest first # mix in an '<Other>' row at a sorted position # Size is either size if sortby = 'Size', # or count if sortby = 'Count'. # Returns a NEW LIST (caller may modify/sort it) if sortby not in ('Size', 'Count'): raise ValueError("Argument 'sortby' must be 'Size' or 'Count'.") # Rows are already sorted by Size, largest first. # If they want by Count, we need to resort them. rows = self.get_rows() if sortby == 'Count': rows = list(rows) rows.sort(key=lambda x: x.count, reverse=True) retrows = [] cumulcount = 0 cumulsize = 0 for (i, r) in enumerate(rows): if i >= N: othercount = self.count - cumulcount othersize = self.size - cumulsize other = StatRow(othercount, othersize, '<Other>') if sortby == 'Size': for (i, r) in enumerate(retrows): if r.size < othersize: retrows[i:i] = [other] break else: retrows.append(other) elif sortby == 'Count': for (i, r) in enumerate(retrows): if r.count < othercount: retrows[i:i] = [other] break else: retrows.append(other) else: assert 0 break cumulcount += r.count cumulsize += r.size retrows.append(r) else: assert cumulcount == self.count assert cumulsize == self.size return retrows def parse_next_row(self): r = self.last if not r: raise IndexError('Row index out of range.') if r.startswith('.r: '): r = r[4:] sr = self.format.load_statrow(r) self.cur_index += 1 self.rows.append(sr) self.get_next() return elif r.startswith('.end'): raise IndexError('Row index out of range.') else: raise SyntaxError class Partition: def __init__(self, mod, set, er): self.mod = mod self.set = set self.er = er self._hiding_tag_ = mod._hiding_tag_ self.timemade = mod.time.time() def __iter__(self): # The default iteration is over the sets # To iterate over rows (if more info is needed), get_rows() is available. return self.get_sets() def get_rows(self, rowindex=None): # Iterator over rows if rowindex is None: rowindex = 0 while 1: try: row = self.get_row(rowindex) except IndexError: return else: yield row rowindex += 1 def get_set(self, index): if isinstance(index, slice): start, stop, step = index.indices(self.numrows) ns = self.get_nodeset(start, stop, step) return self.mod.idset(ns, er=self.er) else: if index < 0: index += self.numrows return self.get_rowset(index) def get_sets(self, index=None): for idx in range(self.numrows): yield self.get_rowset(idx) def get_stat(self): # Avoid any references into the set! trows = list(self.get_trows()) def get_trows(): return trows return self.mod._load_stat(get_trows) def get_trows(self): yield '.loader: _load_stat' yield '.format: %s' % self.format.__class__.__name__ yield '.timemade: %f' % self.timemade yield '.count: %d' % self.count yield '.size: %d' % self.size yield '.kindname: %s' % self.kindname yield '.kindheader: %s' % self.kindheader yield '.numrows: %d' % self.numrows for row in self.get_rows(): yield '.r: %s' % self.format.get_rowdata(row) def init_format(self, FormatClass): self.format = FormatClass(self) self.mod.OutputHandling.setup_printing(self, self.format) class IdentityPartitionCluster(object): # Contains objects of same size. # to speed up management of identity partition # - since otherwise we'd have to sort all the objects, # on their string representation in worst case. __slots__ = 'objects', 'locount', 'hicount', 'losize', 'obsize', 'issorted' def __init__(self, objects, locount, count, losize, obsize): self.objects = objects # tuple of objects in this segment self.locount = locount # count BEFORE objects in this cluster self.hicount = locount+count # count AFTER these objects self.losize = losize # size BEFORE objects in this cluster self.obsize = obsize # size of EACH object in this segment self.issorted = False # indicates if .objects is sorted class IdentityPartition(Partition): def __init__(self, mod, set, er): Partition.__init__(self, mod, set, er) clusters = [] sizeclasses = mod.Size.classifier.partition_cli(set.nodes) sizeclasses.sort() sizeclasses.reverse() totcount = 0 totsize = 0 for size, v in sizeclasses: count = len(v) clusters.append(IdentityPartitionCluster( self.mod.observation_list(v), totcount, count, totsize, size)) totsize += size * count totcount += count assert totcount == set.count self.cluidx = 0 self.clusters = clusters self.count = totcount self.kind = kind = set.byclodo.kind self.kindheader = kind.fam.c_get_idpart_header(kind) self.kindname = kind.fam.c_get_idpart_label(kind) self.numrows = totcount self.render = kind.fam.c_get_idpart_render(kind) self.size = totsize self.sortrender = kind.fam.c_get_idpart_sortrender(kind) self.init_format(IdFormat) def get_nodeset(self, start, stop, step): return self.get_nodeset_cluster(start, stop, step)[0] def get_nodeset_cluster(self, start, stop, step): if step <= 0: raise ValueError('Step must be positive.') ns = self.mod.mutnodeset() if start >= stop: return (ns, None) clusters = self.clusters lo = 0 hi = len(clusters) cluidx = self.cluidx while lo < hi: clu = clusters[cluidx] if clu.locount <= start: if start < clu.hicount: break else: lo = cluidx + 1 else: hi = cluidx cluidx = (lo + hi) // 2 else: return (ns, None) clu_to_return = clu while 1: objects = clu.objects if start != clu.locount or stop < clu.hicount or step != 1: if not clu.issorted: sortrender = self.sortrender if sortrender == 'IDENTITY': ks = objects else: ks = [sortrender(x) for x in objects] ks = [(kind, i) for i, kind in enumerate(ks)] ks.sort() clu.objects = objects = self.mod.observation_list( [objects[i] for (kind, i) in ks]) clu.issorted = True objects = objects[start-clu.locount:stop-clu.locount:step] ns \|= objects self.cluidx = cluidx # memo till next call start += len(objects)step if start >= stop: break for cluidx in range(cluidx + 1, len(clusters)): clu = clusters[cluidx] if clu.locount <= start < clu.hicount: break else: break return (ns, clu_to_return) def get_row(self, rowidx): ns, clu = self.get_nodeset_cluster(rowidx, rowidx+1, 1) if not ns: raise IndexError('Partition index out of range.') vi = self.mod.idset(ns, er=self.er) row = PartRow(1, clu.obsize, self.render(vi.theone), rowidx, (rowidx+1-clu.locount)clu.obsize + clu.losize, vi, vi.kind) return row def get_rowset(self, rowidx): ns = self.get_nodeset(rowidx, rowidx+1, 1) if not ns: raise IndexError('Partition index out of range.') return self.mod.idset(ns, er=self.er) class SetPartition(Partition): def __init__(self, mod, set, er): Partition.__init__(self, mod, set, er) classifier = er.classifier tosort = [(-part.size, classifier.get_tabrendering(kind, ''), kind, part) for (kind, part) in classifier.partition(set.nodes)] tosort.sort() cumulsize = 0 rows = [] for (minusize, name, kind, part) in tosort: size = -minusize cumulsize += size rows.append(PartRow( part.count, size, name, len(rows), cumulsize, part, kind)) self.count = set.count self.kindheader = classifier.get_tabheader('') self.kindname = '' self.numrows = len(rows) self.rows = rows self.size = cumulsize self.init_format(SetFormat) def get_nodeset(self, start, stop, step): if step <= 0: raise ValueError('Step must be positive.') ns = self.mod.mutnodeset() while start < stop: ns \|= self.rows[start].set.nodes start += step return ns def get_row(self, idx): try: return self.rows[idx] except IndexError: raise IndexError('Partition index out of range.') def get_rowset(self, idx): row = self.get_row(idx) set = row.set try: set._partition except AttributeError: set._partition = self.mod._fast_partition(self, row) return set class FastPartition(SetPartition): def __init__(self, mod, parent, row): Partition.__init__(self, mod, parent.set, parent.er) self.count = row.count self.kindheader = parent.kindheader self.kindname = '' self.numrows = 1 self.rows = [row] self.size = row.size self.init_format(SetFormat) class _GLUECLAMP_: _preload_ = ('_hiding_tag_',) _chgable_ = ('line_length', 'backup_suffix') _imports_ = ( '_parent.ImpSet:mutnodeset', '_parent:OutputHandling', '_parent.Use:Id', '_parent.Use:Size', '_parent.Use:idset', '_parent.Use:load', '_parent.View:_hiding_tag_', '_parent.View:observation_list', '_root.os:rename', '_root.textwrap:fill', '_root.textwrap:wrap', '_root.textwrap:wrap', '_root:time', ) # 'Config' line_length = 100 backup_suffix = '.old' # Factory method def partition(self, set, er): if er.classifier is self.Id.classifier: return IdentityPartition(self, set, er) else: return SetPartition(self, set, er) # Private - Use.load is intended to be used directly. def _load_stat(self, get_trows): return Stat(self, get_trows) def _fast_partition(self, parent, row): return FastPartition(self, parent, row)	23.25 KB	2026-01-20 12:58
📄 Path.py import functools from guppy.etc.Descriptor import property_nondata class R_NORELATION: code = -1 r = None def stra(self, a, safe=True): return '%s.??' % a class R_IDENTITY: code = 0 def stra(self, a, safe=True): return a class R_ATTRIBUTE: code = 1 strpat = '%s.%s' class R_INDEXVAL: code = 2 def stra(self, a, safe=True): if safe: return '%s[%s]' % (a, self.saferepr(self.r)) else: return '%s[%r]' % (a, self.r) class R_INDEXKEY: code = 3 strpat = '%s.keys()[%r]' class R_INTERATTR: code = 4 strpat = '%s->%s' class R_HASATTR: code = 5 strpat = '%s.__dict__.keys()[%r]' class R_LOCAL_VAR: code = 6 strpat = '%s.f_locals[%r]' class R_CELL: code = 7 strpat = '%s.f_locals [%r]' class R_STACK: code = 8 strpat = '%s->f_valuestack[%d]' class R_INSET: code = 9 strpat = 'list(%s)[%d]' class R_RELSRC: code = 10 def stra(self, a, safe=True): return self.r % (a,) class R_LIMIT: code = 11 @functools.total_ordering class RelationBase(object): __slots__ = 'r', 'isinverted' def __init__(self, r, isinverted=0): self.r = r self.isinverted = isinverted def __lt__(self, other): if not isinstance(other, RelationBase): return id(type(self)) < id(type(other)) if self.code != other.code: return self.code < other.code if type(self.r) is not type(other.r): return id(type(self.r)) < id(type(other.r)) try: return self.r < other.r except TypeError: return id(self.r) < id(other.r) def __eq__(self, other): if isinstance(other, RelationBase): if self.code != other.code: return False return self.r == other.r else: return False def __str__(self): return self.stra('%s') def inverted(self): return self.__class__(self.r, not self.isinverted) def stra(self, a, safe=True): return self.strpat % (a, self.r) class MultiRelation(RelationBase): def __init__(self, rels): self.rels = rels def stra(self, a, safe=True): return '<'+','.join([x.stra(a, safe=safe) for x in self.rels])+'>' @functools.total_ordering class Path: def __init__(self, mod, path, index, srcname): self.mod = mod self.path = path[1:] self.index = index self.src = path[1] self.tgt = path[-1] self.strprefix = '%s' if srcname == '_str_of_src_': srcname = self.src.brief if callable(srcname): srcname = srcname(self) self.srcname = srcname def __lt__(self, other): return str(self) < str(other) def __eq__(self, other): return str(self) == str(other) def __len__(self): return int((len(self.path) - 1) / 2) def stra(self, safe=True): if self.path: s = self.strprefix for i in range(1, len(self.path), 2): r = self.path[i] s = r.stra(s, safe=safe) else: s = '<Empty Path>' return s def __str__(self): return self.stra() def __repr__(self): return repr(str(self)) def _get_line_iter(self): yield '%2d: %s' % (self.index, str(self) % self.srcname) def types(self): return [type(x) for x in self.path] class PathsIter: def __init__(self, paths, start=None, stop=None): self.paths = paths self.mod = paths.mod self.stop = stop self.reset(start) def __iter__(self): return self def reset(self, idx=None): if idx is None: idx = 0 if idx != 0: # Optimization: don't calculate numpaths in common case. ln = self.paths.numpaths if idx < 0: idx = ln + idx if not (0 <= idx < ln): self.isatend = 1 return Src = self.paths.Src sr = [('%s', src.by(Src.er)) for src in Src.byid.parts] srs = [] idxs = [] np = 0 while sr: if idx == 0: i, (rel, src) = 0, sr[0] else: for i, (rel, src) in enumerate(sr): npnext = np + self.paths.numpaths_from(src) if idx < npnext: break np = npnext else: assert 0 idxs.append(i) srs.append(sr) sr = self.mod.sortedrels(self.paths.IG, src) self.pos = idx self.idxs = idxs self.srs = srs self.isatend = not idxs def __next__(self): paths = self.paths if (self.isatend or self.stop is not None and self.pos >= self.stop): raise StopIteration path = [] for row, col in enumerate(self.idxs): sr = self.srs[row] if sr is None: sr = self.mod.sortedrels(paths.IG, path[-1]) self.srs[row] = sr rel, dst = sr[col] path.append(rel) path.append(dst) rp = self.mod.Path(paths, path, self.pos, paths.srcname) self.pos += 1 while row >= 0: self.idxs[row] += 1 if self.idxs[row] < len(self.srs[row]): break if row > 0: self.srs[row] = None self.idxs[row] = 0 row -= 1 else: self.isatend = 1 self.pos = 0 return rp class ShortestPaths: def __init__(self, sg, Dst): self.sg = sg self.Dst = Dst self.mod = mod = sg.mod self._hiding_tag_ = mod._hiding_tag_ self.srcname = sg.srcname self.top = self self.IG = IG = mod.nodegraph() Edges = [] Y = Dst.nodes while Y: R = sg.G.domain_restricted(Y) R.invert() IG.update(R) Edges.append(R) Y = R.get_domain() if Edges: Edges.pop() Edges.reverse() self.Src = mod.idset(Edges[0].get_domain()) else: self.Src = mod.iso() self.edges = tuple(Edges) sets = [] for i, e in enumerate(Edges): if i == 0: sets.append(mod.idset(e.get_domain())) sets.append(mod.idset(e.get_range())) self.sets = tuple(sets) mod.OutputHandling.setup_printing(self) self.maxpaths = 10 def __getitem__(self, idx): try: return next(self.iter(start=idx)) except StopIteration: raise IndexError def __iter__(self): return self.iter() def iter(self, start=0, stop=None): return PathsIter(self, start, stop) def aslist(self): return list(self) def copy_but_avoid_edges_at_levels(self, args): avoid = self.edges_at(args).updated(self.sg.AvoidEdges) assert avoid._hiding_tag_ is self.mod._hiding_tag_ return self.mod.shpaths(self.Dst, self.Src, avoid_edges=avoid) # return self.mod.shpaths(self.dst, self.src, avoid_edges=avoid) avoided = copy_but_avoid_edges_at_levels # The builtin __len__ doesn't always work due to builtin Python restriction to int result: # so we don't provide it at all to avoid unsuspected errors sometimes. # Use .numpaths attribute instead. # def __len__(self): # return self.numpaths def depth(self): pass def edges_at(self, args): E = self.mod.nodegraph() for col in args: E.update(self.edges[col]) assert E._hiding_tag_ == self.mod._parent.View._hiding_tag_ return E def numpaths_from(self, Src): try: NP = self.NP except AttributeError: NP = self.mod.nodegraph(is_mapping=True) NP.add_edges_n1(self.IG.get_domain(), None) for dst in self.Dst.nodes: NP.add_edge(dst, 1) self.NP = NP numedges = self.mod.hv.numedges IG = self.IG def np(y): n = NP[y] if n is None: n = 0 for z in IG[y]: sn = NP[z] if sn is None: sn = np(z) n += sn numedges(y, z) NP[y] = n return n num = 0 for src in Src.nodes: num += np(src) return num def _get_numpaths(self): num = self.numpaths_from(self.Src) self.numpaths = num return num numpaths = property_nondata(fget=_get_numpaths) @property def maxpaths(self): return self.printer.max_more_lines @maxpaths.setter def maxpaths(self, value): self.printer.max_more_lines = value def _oh_get_num_lines(self): return self.numpaths def _oh_get_line_iter(self): for el in self: yield from el._get_line_iter() def _oh_get_more_msg(self, start_lineno, end_lineno): nummore = self.numpaths-(end_lineno+1) return '<... %d more paths ...>' % nummore def _oh_get_empty_msg(self): if self.numpaths: return '<No more paths>' return None class ShortestGraph: def __init__(self, mod, G, DstSets, Src, AvoidEdges, srcname=None, dstname=None): self.mod = mod self.G = G self.Src = Src self.DstSets = DstSets self.AvoidEdges = AvoidEdges if srcname is None: if Src.count == 1: srcname = mod.srcname_1 else: srcname = mod.srcname_n self.srcname = srcname if dstname is None: dstname = mod.dstname self.dstname = dstname def __getitem__(self, idx): return self.mod.ShortestPaths(self, self.DstSets[idx]) def __len__(self): return len(self.DstSets) def __repr__(self): lst = [] for i, p in enumerate(self): lst.append('--- %s[%d] ---' % (self.dstname, i)) lst.append(str(p)) return '\n'.join(lst) class _GLUECLAMP_: _preload_ = ('_hiding_tag_',) _chgable_ = ('output', 'srcname_1', 'srcname_n') srcname_1 = 'Src' srcname_n = '_str_of_src_' dstname = 'Dst' _imports_ = ( '_parent.ImpSet:mutnodeset', '_parent:OutputHandling', '_parent.Use:idset', '_parent.Use:iso', '_parent.Use:Nothing', '_parent.Use:reprefix', '_parent.UniSet:idset_adapt', '_parent.View:hv', '_parent.View:nodegraph', '_parent:View', # NOT View.root, since it may change ) def _get_rel_table(self): table = {} for name in dir(self._module): if name.startswith('R_'): c = getattr(self, name) class r(c, self.RelationBase): repr = self.saferepr saferepr = self.saferepr r.__qualname__ = r.__name__ = 'Based_'+name table[c.code] = r return table def _get__hiding_tag_(self): return self._parent.View._hiding_tag_ def _get_identity(self): return self.rel_table[R_IDENTITY.code]('') def _get_norelation(self): return self.rel_table[R_NORELATION.code]('') def _get_saferepr(self): return self._root.reprlib.repr def _get_shpathstep(self): return self.hv.shpathstep def sortedrels(self, IG, Src): t = [] iso = self.iso for src in Src.nodes: for dst in IG[src]: Dst = iso(dst) for rel in self.relations(src, dst): t.append((rel, Dst)) t.sort(key=lambda x: x[0]) return t def prunedinverted(self, G, Y): IG = self.nodegraph() while Y: R = G.domain_restricted(Y) R.invert() IG.update(R) Y = R.get_domain() return IG def relation(self, src, dst): tab = self.relations(src, dst) if len(tab) > 1: r = MultiRelation(tab) elif not tab: r = self.norelation else: r = tab[0] return r def relations(self, src, dst): tab = [] if src is dst: tab.append(self.identity) rawrel = self.hv.relate(src, dst) for i, rs in enumerate(rawrel): for r in rs: tab.append(self.rel_table[i](r)) if not tab: tab = [self.norelation] return tab def shpaths(self, dst, src=None, avoid_nodes=None, avoid_edges=()): return self.shpgraph([dst], src, avoid_nodes, avoid_edges)[0] def shpgraph(self, DstSets, src=None, avoid_nodes=None, avoid_edges=(), srcname=None, dstname=None): if src is None: Src = self.iso(self.View.root) if srcname is None and self.View.root is self.View.heapyc.RootState: srcname = '%sRoot' % self.reprefix else: Src = self.idset_adapt(src) if avoid_nodes is None: AvoidNodes = self.Nothing else: AvoidNodes = self.idset_adapt(avoid_nodes) AvoidEdges = self.nodegraph(avoid_edges) G, DstSets = self.shpgraph_algorithm( DstSets, Src, AvoidNodes, AvoidEdges) return self.ShortestGraph(self, G, DstSets, Src, AvoidEdges, srcname, dstname) def shpgraph_algorithm(self, DstSets, Src, AvoidNodes, AvoidEdges): U = (Src - AvoidNodes).nodes S = self.mutnodeset(AvoidNodes.nodes) G = self.nodegraph() unseen = list(enumerate(DstSets)) DstSets = [self.Nothing]*len(DstSets) while U and unseen: S \|= U U = self.shpathstep(G, U, S, AvoidEdges) unseen_ = [] for i, D in unseen: D_ = D & U if D_: DstSets[i] = D_ else: unseen_.append((i, D)) unseen = unseen_ return G, [self.idset_adapt(D) for D in DstSets] class _Specification_: class GlueTypeExpr: exec("""\ shpgraph <in> callable """.replace('<in>', ' = lambda IN : '))	14.19 KB	2026-01-20 12:58
📄 Prof.py from tkinter import * import tkinter.filedialog import tkinter.messagebox from guppy.etc.Descriptor import property_nondata class MyVar(StringVar): _default = 0.0 def set(self, value): StringVar.set(self, '%.2g' % value) suffixes = ('', 'K', 'M', 'G', 'T') def sizestring(value): value = float(value) sign = 1 if value < 0: sign = -1 value = - value i = 0 while value > 99999: value /= 1000 i += 1 s = str(int(round(value)))+suffixes[i] if s.endswith('000'+suffixes[i]): s = str(int(round(value/1000)))+suffixes[i+1] if sign == -1: s = '-' + s return s def percentstring(value): a = abs(value) if 10 <= a <= 9999: return '%d' % round(value) elif 0.01 <= a <= 10: return '%.2g' % value elif a <= 1e-10: return '0' else: return '%.0e' % value def stringsize(s): if s.isdigit(): return int(s) suf = s[-1:].upper() mult = 1000 for su in suffixes[1:]: if su == suf: break mult = 1000 else: raise ValueError return int(s[:-1])mult class Menu(Menu): # A fix for the .delete() method in Menu. # To delete commands defined in the menu items deleted. # Also changed the comment: INDEX2 is actually INCLUDED. def delete(self, index1, index2=None): """Delete menu items between INDEX1 and INDEX2 (included).""" if index2 is None: index2 = index1 # First find out what entries have defined commands. cmds = [] for i in range(self.index(index1), self.index(index2)+1): c = str(self.entrycget(i, 'command')) if c in self._tclCommands: # I don't want to delete the command already, since it # seems mystical to do that while the entry is not yet deleted. cmds.append(c) # Delete the menu entries. self.tk.call(self._w, 'delete', index1, index2) # Now that the menu entries have been deleted, # we can delete their commands. for c in cmds: self.deletecommand(c) class SizeVar(StringVar): _default = 0.0 def set(self, value): self._value = value s = sizestring(value) StringVar.set(self, s) class ValueLabel(Label): def __init__(self, args, kwds): kwds['width'] = 10 Label.__init__(self, args, kwds) class ClickButton(Button): # Button that runs the command directly at the click, not at release. # And has auto-repeat. def __init__(self, master, command, firstdelay=500, thendelay=150, kwds): Button.__init__(self, master, *kwds) self._command = command self._firstdelay = firstdelay self._thendelay = thendelay self.bind('<Button-1>', self._event_button) self.bind('<ButtonRelease-1>', self._event_release) def _event_button(self, event=None): self._command() if event is not None: delay = self._firstdelay else: delay = self._thendelay self._after = self.after(delay, self._event_button) def _event_release(self, event): self.after_cancel(self._after) del self._after class Stats: def __init__(self, mod, fn=None): self.mod = mod self.os = mod.os self.hashlib = mod.hashlib self.fn = fn def clear_cache(self): # It is intended to be transparently # automagically reopened when needed. self.stats = None del self.stats def get_stats(self): self.open(self.fn) return self.stats stats = property_nondata(get_stats) def collect(self): if not self.fn: return 0, 0 stat = self.os.stat(self.fn) if stat == self.laststat: return len(self), 0 with open(self.fn) as f: str = f.read(self.lastfilesize) md5 = self.hashlib.md5(str.encode('utf-8')) digest = md5.digest() if digest == self.lastdigest: numoldstats = len(self) else: self.loadstr(str, reset=1) numoldstats = 0 str = f.read() self.laststat = self.os.fstat(f.fileno()) self.lastfilesize = self.laststat.st_size md5.update(str.encode('utf-8')) self.lastdigest = md5.digest() self.loadstr(str) numnewstats = len(self.stats)-numoldstats return numoldstats, numnewstats def open(self, fn): if not fn: self.len_stats = 0 self.stats = [] self.max_size = 0 self.fn = fn return with open(fn) as f: str = f.read() lastdigest = self.hashlib.md5(str.encode('utf-8')).digest() laststat = self.os.fstat(f.fileno()) self.loadstr(str, reset=1) # Update these only if there was no exception so far. self.fn = fn self.lastdigest = lastdigest self.laststat = laststat self.lastfilesize = laststat.st_size def loadstr(self, str, reset=0): stats = [] lines = str.split('\n') del str linesiter = iter(lines) max_size = 0 while 1: try: st = self.mod.Use.load(linesiter) except StopIteration: break stats.append(st) if st.size > max_size: max_size = st.size # Only update self if there were no exception so far if reset: self.stats = [] self.max_size = 0 self.max_size = max(self.max_size, max_size) self.stats.extend(stats) self.len_stats = len(self.stats) def __getitem__(self, idx): return self.stats[idx] def __len__(self): try: return self.len_stats except AttributeError: self.len_stats = len(self.stats) return self.len_stats def get_max_size(self): return self.max_size class ProfileRow: kindwidth = 30 def __init__(self, master, row, usecolor=1): self.master = master self.row = row if usecolor: colbg = Frame(master=master, bg='black', width=1, borderwidth=1, relief=GROOVE) self.color = Label(master=colbg, bg='white', width=1, borderwidth=1, relief=GROOVE) self.color.grid(row=0, column=0) colbg.grid(row=row, column=0, sticky=NW) self.rsizevar = SizeVar() self.rsize = Label( master=master, textvariable=self.rsizevar, width=6, anchor=E) self.rpercentvar = StringVar() # BBIntVar() self.rpercent = Label( master=master, textvariable=self.rpercentvar, width=3, anchor=E) self.dsizevar = SizeVar() self.dsize = Label( master=master, textvariable=self.dsizevar, width=6, anchor=E) self.dpercentvar = StringVar() # BBIntVar() self.dpercent = Label( master=master, textvariable=self.dpercentvar, width=3, anchor=E) self.kindvar = StringVar() self.kind = Label(master=master, textvariable=self.kindvar, anchor=NW, width=self.kindwidth, justify=LEFT) self.rsize.grid(row=row, column=1, sticky=NE) self.rpercent.grid(row=row, column=2, sticky=NE) self.dsize.grid(row=row, column=3, sticky=NE) self.dpercent.grid(row=row, column=4, sticky=NE) self.kind.grid(row=row, column=5, sticky=NW) def set_color_size_percent_kind(self, color, rsize, rpercent, dsize, dpercent, kind): self.set_color(color) if color is not None: self.set_color(color) self.rsizevar.set(rsize) if rpercent is None: rpercent = '' else: rpercent = str(int(round(rpercent))) self.rpercentvar.set(rpercent) self.dsizevar.set(dsize) dpercent = str(int(round(dpercent))) self.dpercentvar.set(dpercent) self.set_kind(kind) def set_color(self, color): self.color.configure(bg=color) def set_kind(self, kind): self.kindtext = kind if len(kind) > self.kindwidth: import textwrap kind = textwrap.fill(kind, width=self.kindwidth) self.kindvar.set(kind) def clear(self): self.set_color_size_percent_kind(self.master['bg'], 0, 0, 0, 0, '--') class AxisControl: scale_table = [1, 2, 5] while scale_table[-1] < 1e12: scale_table.append(scale_table[-3] 10) def __init__(self, master, name, range, grid, unit, rangecommand, gridcommand, autocommand=None ): small = 0 self.name = name self.unit = unit self.range = range self.rangecommand = rangecommand self.frame = frame = Frame(master, borderwidth=2, relief=GROOVE) self.rangevar = SizeVar() self.rangevar.set(range) rangeval = Entry(master=self.frame, # anchor=E, width=4, textvar=self.rangevar, #font=('fixed', '16', 'bold'), #font=('terminal', '16', 'bold'), #font=('terminal', '14'), font=('fixed', '14'), # bg='black',fg='yellow' bg='#fdd' ) rangeval.bind('<KeyPress-Return>', self.event_range_enter) namelabel = Menubutton(frame, text=name, relief='raised', anchor=W) namemenu = Menu(namelabel) namelabel['menu'] = namemenu if autocommand: self.autovar = BooleanVar() self.autovar.set(True) namemenu.add_checkbutton( # autobutton = Checkbutton(frame, label='Auto', variable=self.autovar, command=autocommand, # relief=RAISED ) autobutton = Checkbutton(frame, text='Auto', variable=self.autovar, command=autocommand, relief=RAISED ) else: self.autovar = None if gridcommand: self.gridvar = BooleanVar() self.gridvar.set(grid) namemenu.add_checkbutton( label='Grid', variable=self.gridvar, command=lambda: gridcommand(self.gridvar.get()), ) gridbutton = Checkbutton(frame, text='Grid', variable=self.gridvar, command=lambda: gridcommand( self.gridvar.get()), relief=RAISED ) rangelabel = Label(frame, text='Range') if name == 'Y' and small: padx = 5 pady = 0 else: padx = 3 pady = 3 ud = Frame(frame) rangeup = ClickButton(ud, text='+', pady=pady, padx=padx, font=('fixed', 8), command=lambda: self.range_button(1)) rangedown = ClickButton(ud, text='-', pady=pady, padx=padx, font=('fixed', 8), command=lambda: self.range_button(-1)) rangedown.grid(row=0, column=0) rangeup.grid(row=0, column=1) row = 0 if small and name == 'Y': namelabel.grid(row=0, rowspan=1, column=0) rangeup.grid(row=0, column=1, sticky=W) autobutton.grid(row=1, column=0) rangedown.grid(row=1, column=1, sticky=W) rangeval.grid(row=2, column=0, columnspan=2, sticky=W, padx=3, pady=3) elif small and name == 'X': namelabel.grid(row=0, column=0) rangeval.grid(row=0, column=1, sticky=W, padx=3, pady=3) rangedown.grid(row=0, column=2, sticky=W) rangeup.grid(row=0, column=3, sticky=W) else: namelabel.grid(row=row, column=0, sticky=N+W, ipadx=0, ipady=0, padx=2, pady=2) rangelabel.grid(row=row, column=1, sticky=W) ud.grid(row=row, column=2, padx=2) row += 1 if gridcommand: gridbutton.grid(row=row, column=0, sticky=W) rangeval.grid(row=row, column=1, padx=3, pady=3) if autocommand: pass autobutton.grid(row=row, column=2) def cmd_range(self): pass def event_range_enter(self, event): str = self.rangevar.get() try: rng = stringsize(str) if rng not in self.scale_table: if not 1 <= rng <= self.scale_table[-1]: raise ValueError except ValueError: self.frame.bell() self.errorbox("""\ Invalid range entry. It should be a positive integer with an optional multiplier: K, M, G, or T (1000, 1e6, 1e9, 1e12) Maximum range is 1T.""") self.rangevar.set(self.range) else: if self.autovar: self.autovar.set(False) self.setrange(rng) def auto_command(self): pass def errorbox(self, msg): tkinter.messagebox.showerror(master=self.frame, message=msg) def fit(self, range): range = self.scale_by_table(range) self.setrange(range) def range_button(self, d): if self.autovar: self.autovar.set(False) self.range_change(d) def range_change(self, d): range = self.range srange = self.scale_by_table(range) if srange > range: if d > 0: d -= 1 i = self.scale_table.index(srange) i += d if i >= len(self.scale_table): i = len(self.scale_table) - 1 if i < 0: i = 0 self.setrange(self.scale_table[i]) def setrange(self, range): if range != self.range: self.range = range self.rangevar.set(range) self.rangecommand(range) def scale_by_table(self, s): # Return the scale from table that is higher or equal to s for ts in self.scale_table: if ts >= s: return ts return self.scale_table[-1] WM = 1 class Marker: def __init__(self, d, tag, name, pos, poscommand=None): self.d = d self.tag = tag self.name = name self.xmarker = pos self.butdown = 0 self.ocursor = d.ocursor self.cursor = self.ocursor self.poscommand = None self.intpos = None self.moving = 0 self.selected = 0 self.entered = 0 self.butdownselected = 0 self.motion_id = None self.create() def bind(self, sequence, function): tag = self.tag self.d.drawingarea.tag_bind(tag, sequence, function) if WM: self.xlabel.bind(sequence, function) else: self.d.xmarks.tag_bind(tag, sequence, function) def coords(self, canx): self.d.drawingarea.coords(self.tag, canx, 0, canx, -int(self.d.boty)) self.d.xmarks.coords(self.tag, canx, 10) def create(self): tag = self.tag text = self.name pos = 0 self.d.drawingarea.create_line(pos, 0, pos, 20-self.d.boty, stipple='gray12', width=4, tags=(tag,)) if WM: label = self.xlabel = Label( self.d.xmarks, text=text, padx=2, pady=2, relief=RAISED) self.d.xmarks.create_window(pos, 0, window=label, tags=(tag,)) else: self.d.xmarks.create_text(pos, 0, text=text, tags=(tag,)) self.bind('<Button-1>', self.event_button_1) self.bind('<ButtonRelease-1>', self.event_button_1_release) self.bind('<Enter>', self.event_enter) self.bind('<Leave>', self.event_leave) self.d.drawingarea.bind('<Enter>', self.event_enter_movearea, add='+') self.d.drawingarea.bind( '<Button-1>', self.event_button_1_movearea, add='+') def event_button_1(self, event): self.butdown = 1 if self.selected: self.butdownselected = 1 if self.moving: self.event_stop_move(event) else: self.butdownselected = 0 self.has_moved = 0 self.event_selected(event) self.event_start_move(event) def event_button_1_movearea(self, event): if not self.entered: self.event_deselected(event) def event_button_1_release(self, event): self.butdown = 0 if self.has_moved == self.butdownselected: if self.selected: if self.moving and not (self.disloy <= event.y_root < self.dishiy): self.event_stop_move(None) self.setcursor(self.ocursor) else: self.setcursor(self.ocursor) return self.event_deselected(event) def event_deselected(self, event): if self.selected: self.selected = 0 self.xlabel['relief'] = RAISED if self.moving: self.event_stop_move(event) def event_enter(self, event): self.entered = 1 if not self.moving: if self.selected: self.event_start_move(event) else: self.setcursor('hand2') def event_enter_movearea(self, event): if self.selected and not self.moving: self.event_start_move(event) def event_leave(self, event): self.entered = 0 if not self.moving: self.setcursor(self.ocursor) elif not (self.fraloy <= event.y_root < self.frahiy): pass def event_motion(self, event): self.has_moved = 1 inside = (self.fraloy <= event.y_root < self.frahiy) if inside != self.inside: self.inside = inside if not inside: self.out_event = event self.event_stop_move(None) if self.butdown: self.setcursor('circle') self.d.bind_motion(self.event_motion_downout) else: self.in_event = event #self.delta += self.out_event.x_root - event.x_root self.event_start_move(event) return if inside: self.moved(event) self.setxvars() def event_motion_downout(self, event): # We don't get an enter while button is pressed down # Emulate an enter if we detect entering inside = (self.fraloy <= event.y_root < self.frahiy) if inside: self.d.unbind_motion(self.event_motion_downout) self.event_enter_movearea(event) def event_selected(self, event): for m in self.d.marks: m.event_deselected(event) self.selected = 1 self.xlabel['relief'] = SUNKEN def event_start_move(self, event): self.moving = 1 self.fralox = self.d.frame.winfo_rootx() self.frahix = self.fralox + self.d.frame.winfo_width() self.fraloy = self.d.frame.winfo_rooty() self.frahiy = self.fraloy + self.d.frame.winfo_height() self.dislox = self.d.drawingarea.winfo_rootx() self.dishix = self.dislox + self.d.drawingarea.winfo_width() self.disloy = self.d.drawingarea.winfo_rooty() self.dishiy = self.disloy + self.d.drawingarea.winfo_height() self.down_event = event self.prev_event = event self.down_xmarker = self.xmarker self.down_xvfrac = self.d.drawingarea.xview()[0] self.inside = 1 self.delta = 0 self.lift() self.motion_id = self.d.bind_motion(self.event_motion) self.moved(event) def event_stop_move(self, event): assert self.moving self.moving = 0 self.d.unbind_motion(self.motion_id) if event is not None: self.moved(event) self.setxvars() if self.entered and not self.selected: self.setcursor('hand2') else: self.setcursor(self.ocursor) def lift(self): self.d.xmarks.tag_raise(self.tag) if WM: self.xlabel.lift() self.d.drawingarea.tag_raise(self.tag) def move(self, sample): canx = self.d.canxscaled(sample) self.d.xview_pos(canx) self.coords(canx) self.xmarker = sample self.lift() def moved(self, event): curx = event.x_root cury = event.y_root prevx = self.prev_event.x_root if prevx > self.dishix and curx < self.dishix: prevx = self.dishix elif prevx < self.dislox and curx > self.dislox: prevx = self.dislox markx = self.d.canxscaled(self.xmarker) - \ self.d.drawingarea.canvasx(0) + self.dislox dx = curx - prevx l = r = 1 if self.xmarker >= self.d.numstats-1: r = 0 if self.xmarker <= 0: l = 0 stop = 0 # Should we allow to move it back or not # if it is at an endpoint? # Here we don't move it at all, to make marker pos correspond # more closely with mouse position. if ((r == 0 and curx > markx) or (l == 0 and curx < markx)): l = r = 0 if self.butdown: if curx > self.dishix: l = 0 elif curx < self.dislox: r = 0 else: if not (self.dislox <= curx < self.dishix and self.disloy <= cury < self.dishiy): l = r = 0 stop = 1 if l and r: self.setcursor('sb_h_double_arrow') elif l: self.setcursor('sb_left_arrow') if dx > 0: dx = 0 elif r: self.setcursor('sb_right_arrow') if dx < 0: dx = 0 else: self.setcursor('dot') dx = 0 self.prev_event = event sample = self.d.limitx(self.xmarker + dx / self.d.xscale) canx = self.d.canxscaled(sample) self.d.xview_pos(canx) self.coords(canx) self.xmarker = sample if stop and self.moving: self.event_stop_move(None) def set(self): canx = self.d.canxscaled(self.xmarker) self.coords(canx) self.lift() def set_poscommand(self, command): self.poscommand = command self.intpos = None def setcursor(self, cursor): if cursor != self.cursor: self.xlabel['cursor'] = cursor self.cursor = cursor self.d.setcursor(cursor) def setxvars(self): if self.poscommand: intpos = int(round(self.xmarker)) if intpos != self.intpos: self.intpos = intpos self.poscommand(intpos) class Display: orgwidth = 300 orgheight = 300 minwidth = 30 minheight = 30 def __init__(self, master, scale_table, numkindrows, getkindcolor, xrange=100, yrange=100, xgrid=False, ygrid=False, graphtype='Bars', statype='Size', ): self.master = master self.scale_table = scale_table self.numkindrows = numkindrows self.getkindcolor = getkindcolor self.xrange = xrange self.yrange = yrange self.xgrid = xgrid self.ygrid = ygrid self.var_xgrid = BooleanVar() self.var_xgrid.set(xgrid) self.var_ygrid = BooleanVar() self.var_ygrid.set(ygrid) self.graphtype = graphtype self.statype = statype self.numstats = 0 self.ymaxs = [] self.ymins = [] self.ymax = 1 # To get around problems with dynamic unbinding / unbinding of motion, # I handle it myself. in the bind_motion method using the following. self.bound_motions = {} self.event_motion_id = None # self.frame = frame = Frame(master, borderwidth=3, relief=SUNKEN, # relief=GROOVE, # background='green' ) #self.frame = frame = Frame(master,background='green') bordercolor = '#ccc' screencolor = '#e0e0e0' xscrollincrement = 1 frame = Frame(self.frame) frame.grid(row=0, column=0) #move = Frame(frame, height=10,width=10,background='red', relief=RAISED) #move = Button(self.frame, height=10,width=10,background='red') self.drawingarea = C = Canvas(frame, width=self.orgwidth, height=self.orgheight, xscrollincrement=xscrollincrement, # background='black', background=screencolor, bd=0, xscrollcommand=self.xscrollbar_set, # confine=False, ) #self.yctrlframe = Frame(frame, borderwidth=2,relief=GROOVE) self.yscrollbar = Scrollbar(frame, orient=VERTICAL, width=10) # self.yscrollbar['command']=self.drawingarea.yview #self.drawingarea['yscrollcommand'] = self.yscrollbar_set # self.yscrollbar.pack(side=RIGHT,fill=Y) #self.yctrlframe.grid(row = 0, column = 0,sticky=N+S,padx=3,pady=3) self.xaxis = Canvas(frame, width=C['width'], height=20, xscrollincrement=xscrollincrement, bd=0, background=bordercolor, #xscrollcommand = self.xscrollbar_set # confine=False, ) self.xmarks = Canvas(frame, width=C['width'], height=20, xscrollincrement=xscrollincrement, bd=0, background=bordercolor, #xscrollcommand = self.xscrollbar_set # confine=False, ) self.yaxis = Canvas(frame, height=C['height'], width=50, bd=0, background=bordercolor, ) self.xscrollbar = Scrollbar(frame, orient=HORIZONTAL, command=self.drawingarea_xview, width=12, background=bordercolor, ) xy = Canvas(frame, width=50, height=20, bd=0, background=bordercolor, ) var_yrange = SizeVar() self.var_yrange = var_yrange row = 0 Label(frame, textvar=var_yrange, bd=0, relief=FLAT, background=bordercolor).grid( row=row, column=0, sticky=W+E+N+S) self.xscrollbar.grid(row=row, column=1, sticky=E+W) row += 1 self.yunit = Label(frame, text='Bytes', bd=0, relief=FLAT, background=bordercolor) self.yunit.grid( row=row, column=0, sticky=W+E+N+S) self.xmarks.grid(row=row, column=1, sticky=W+E+N) row += 1 self.yaxis.grid(row=row, column=0) C.grid(row=row, column=1, sticky=W+E) row += 1 xy.grid(row=row, column=0) self.xaxis.grid(row=row, column=1, sticky=W+E+N) self.botx = float(C['width']) self.boty = float(C['height']) self.chdim = self.getchdim() self.canx0 = 0 self.tmax = 0 self.xscale = self.botx / self.xrange self.yscale = self.boty / self.yrange self.xi0 = None xy.create_line(0, 2, 44, 2) xy.create_line(49, 6, 49, 22) xy.create_text(25, 14, text='Sample') self.setscrollregion() self.ocursor = self.drawingarea['cursor'] self.cursor = self.ocursor self.marks = [] def bind_motion(self, function): if self.event_motion_id == None: self.event_motion_id = self.frame.bind_all( '<Motion>', self.event_motion, add='+') self.bound_motions[function] = self.bound_motions.get(function, 0) + 1 return function def event_motion(self, event): for f in list(self.bound_motions.keys()): f(event) def unbind_motion(self, funcid): n = self.bound_motions[funcid] - 1 if n == 0: del self.bound_motions[funcid] else: self.bound_motions[funcid] = n def new_xmarker(self, name=None, pos=0): tag = 'M%d' % len(self.marks) if name is None: name = tag m = Marker(self, tag, name, pos) self.marks.append(m) return m def canxscaled(self, x): return x * self.xscale + self.canx0 def canyscaled(self, y): return - y * self.yscale def cmd_xgrid(self): self.xgrid = self.var_xgrid.get() self.drawxaxis() def cmd_ygrid(self): self.ygrid = self.var_ygrid.get() self.drawyaxis() def cmd_yrange_auto(self): self.ymax = None self.yrange_auto() def limitx(self, x): lo = 0 hi = max(0, self.numstats-1) if x < lo: return lo if x > hi: return hi return x def resize(self, dx, dy): x = self.botx + dx y = self.boty + dy if x < self.minwidth: x = self.minwidth dx = x - self.botx if y < self.minheight: y = self.minheight dy = y - self.boty xv = self.drawingarea.xview() yv = self.drawingarea.yview() self.drawingarea.configure(width=x, height=y) self.xaxis.configure(width=x) self.xmarks.configure(width=x) self.yaxis.configure(height=y) xscale = float(x) / self.xrange yscale = float(y) / self.yrange xscaleorg = self.drawingarea.canvasx(0) yscaleorg = 0 xq = xscale / self.xscale yq = yscale / self.yscale self.drawingarea.scale("all", xscaleorg, yscaleorg, xq, yq) #self.drawingarea.scale("barsep",xscaleorg, yscaleorg, xq, yq) #self.drawingarea.scale("xmarker",xscaleorg, yscaleorg, xq, yq) self.canx0 = xscaleorg + (self.canx0 - xscaleorg) * xq self.botx = x self.boty = y self.xscale = xscale self.yscale = yscale self.drawxaxis() self.drawyaxis() self.setscrollregion() # If the size changed much, the canvas may scroll though it shouldn't. # Notes 11 and 26 Oct 2005 . # I save the current scroll position. # The caller has to call the .moveback() method some time later. self.wantedpos = xv[0] return dx, dy def moveback(self): self.frame.update_idletasks() self.xview(MOVETO, self.wantedpos) def draw(): self.drawxaxis() self.drawyaxis() def draw_stat(self, idx, stat): graphtype = self.graphtype statype = self.statype rows = stat.get_rows_n_and_other(self.numkindrows, statype) if statype == 'Size': kindval = dict([(r.name, r.size) for r in rows]) else: kindval = dict([(r.name, r.count) for r in rows]) order = [r.name for r in rows] order.reverse() lastkindval = self.lastkindval self.lastkindval = kindval C = self.drawingarea yscale = self.yscale xscale = self.xscale x0 = idx * xscale - 0.5 * xscale + self.canx0 x1 = x0 + xscale ymax = 0 ymin = 0 y = 0 bw = 0.05xscale ocolor = None for k in order: dy = kindval.get(k, 0) if not dy: continue color = self.getkindcolor(k) if graphtype == 'Bars': line = C.create_rectangle(x0+bw, -yyscale, x1-bw, -(y+dy)yscale, fill=color, outline=color, width=0, tags=("a",)) if color == ocolor: C.create_line(x0, -(y)yscale, x1, -(y)yscale, fill='black', tags=('barsep',)) ocolor = color y += dy elif graphtype == 'Lines': if dy > ymax: ymax = dy elif dy < ymin: ymin = dy y0 = lastkindval.get(k) if y0 is None: y0 = dy x00 = x0 else: x00 = x0 - 0.4 xscale C.create_line(x00, - y0 * yscale, x1 - 0.6 * xscale, - dy * yscale, fill=color, tags=('a',)) C.create_line(x1 - 0.6 * xscale, - dy * yscale, x1 - 0.4 * xscale, - dy * yscale, fill=color, width=4, tags=('a',)) if graphtype == 'Bars': if y > ymax: ymax = y elif y < ymin: ymin = y assert idx == len(self.ymaxs) == len(self.ymins) self.ymaxs.append(ymax) self.ymins.append(ymin) if idx > self.tmax: self.tmax = idx def drawingarea_xview(self, cmd, what, unit=None): if cmd == 'scroll' and unit == 'units': what = int(max(2, self.xscale)int(what)) self.xview(cmd, what, unit) def setcursor(self, cursor): if cursor != self.cursor: self.drawingarea['cursor'] = cursor self.master['cursor'] = cursor self.cursor = cursor def xmarkers_set(self): for m in self.marks: m.set() def xview(self, args): if not args: return self.drawingarea.xview() self.drawingarea.xview(args) self.xaxis.xview(args) self.xmarks.xview(args) def xview_moveto(self, fraction): self.xview(MOVETO, fraction) def xview_pos(self, pos, fraction=None, leftmargin=5, rightmargin=5): # Scroll canvas view, if necessary, so that something # (eg an x marker) at canvas position pos will be visible # with minimum specified margin at left and right. # Scroll relative to fraction; default is current xview position. if fraction is None: fraction = self.xview()[0] x1, y1, x2, y2 = self.scrollregion cc = x1 + fraction (x2 - x1) xm = pos - cc lo = leftmargin hi = self.botx - rightmargin if xm < lo: dx = xm - lo xm = lo elif xm >= hi: dx = (xm - hi) xm = hi else: dx = 0 r = fraction + dx / float(x2 - x1) self.xview_moveto(r) def drawxaxis(self): scale_table = self.scale_table self.xaxis.delete('all') self.drawingarea.delete('xgrid') x1, y1, x2, y2 = self.scrollregion chdx, chdy = self.chdim i = 0 while (scale_table[i] * self.xscale < min(5, len(str(scale_table[i] * self.tmax))) * chdx): i += 1 self.xstep = scale_table[i] divisuf = ( (1000000000000, '%dT'), (1000000000, '%dG'), (1000000, '%dM'), (1000, '%dK'), (1, '%d') ) for divi, form in divisuf: if self.xstep >= divi: break self.xdivi = divi self.xform = form self.xi0 = 0 self.updatexaxis() def updatexaxis(self): chdx, chdy = self.chdim step = self.xstep gridon = self.xgrid for i in range(self.xi0, self.tmax+step, step): x = self.canx0 + iself.xscale self.xaxis.create_line(x, 0, x, 4) if gridon: self.drawingarea.create_line(x, 0, x, -self.boty, tags=('xgrid',), width=2, stipple="gray25") text = self.xform % (i / self.xdivi) self.xaxis.create_text(x, chdy, text=text) self.xaxis.create_line(self.canx0 + self.xi0 self.xscale, 1, x+self.xscale, 1) self.xi0 = i self.xmarkers_set() def drawyaxis(self): gridon = self.ygrid self.yaxis.delete('all') self.drawingarea.delete('ygrid') chdx, chdy = self.getchdim() width = int(self.yaxis['width']) i = 0 maxval = self.yrange while (self.scale_table[i] * self.yscale < 1.5 * chdy): i += 1 step = self.scale_table[i] divisuf = ( (1000000000000, '%4dT'), (1000000000, '%4dG'), (1000000, '%4dM'), (1000, '%4dK'), (1, '%5d') ) for divi, form in divisuf: if step >= divi: break for i in range(0, maxval+step, step): y = - iself.yscale self.yaxis.create_line(width-3, y, width-1, y) if gridon: self.drawingarea.create_line(self.scrollregion[0], y, self.scrollregion[2], y, stipple="gray25", tags=('ygrid',)) text = form % (i / divi) self.yaxis.create_text(chdx2.5, y-0.5chdy, text=text) #self.yaxis.create_text(chdx2.5, 0.5chdy, text='bytes') self.yaxis.create_line(width-1, 0, width-1, -self.boty) self.xmarkers_set() def getchdim(self): ch = self.xaxis.create_text(0, 0, text='0') x1, y1, x2, y2 = self.xaxis.bbox(ch) self.xaxis.delete(ch) chdx = abs(x2 - x1) chdy = abs(y2 - y1) return chdx, chdy def load_stats(self, stats): ocursor = self.frame.winfo_toplevel()['cursor'] try: self.frame.winfo_toplevel()['cursor'] = 'watch' self.frame.update() self.numstats = len(stats) self.lastkindval = {} self.tmax = 0 self.ymax = None self.ymaxs = [] self.ymins = [] C = self.drawingarea C.delete('barsep') C.delete('a') for (i, st) in enumerate(stats): self.draw_stat(i, st) try: self.drawingarea.tag_raise('barsep', 'a') except TclError: pass # May be 'tagOrId "a" doesn't match any items' if empty! self.drawxaxis() self.drawyaxis() self.xmarkers_set() self.yrange_auto() finally: self.frame.winfo_toplevel()['cursor'] = ocursor def add_stats(self, stats): for (i, st) in enumerate(stats): self.draw_stat(i+self.numstats, st) self.numstats += len(stats) self.updatexaxis() self.setscrollregion() def setxgrid(self, grid): self.xgrid = grid self.drawxaxis() def setygrid(self, grid): self.ygrid = grid self.drawyaxis() def setgraphtype(self, gmode, stats): graphtype, statype = gmode.split(' ') if graphtype != self.graphtype or statype != self.statype: self.graphtype = graphtype self.statype = statype if statype == 'Size': self.yunit['text'] = 'Bytes' elif statype == 'Count': self.yunit['text'] = 'Objects' else: raise ValueError self.load_stats(stats) def setscrollregion(self): C = self.drawingarea botx = self.botx x1 = self.canx0 x2 = self.tmax self.xscale + self.canx0 x1extra = botx / 2 + 2 # max(5, self.xscale0.5) x2extra = botx / 2 + 2 # max(5, self.xscale0.5) x1 -= x1extra x2 += x2extra y1 = 1-self.boty y2 = 1 self.scrollregion = (x1, y1, x2, y2) C.configure(scrollregion=self.scrollregion) self.xaxis.configure(scrollregion=(x1, 0, x2, 10)) self.xmarks.configure(scrollregion=(x1, 0, x2, 20)) self.yaxis.configure(scrollregion=(0, y1, 20, y2)) self.drawingarea.yview(MOVETO, 0.0) def setxrange(self, xrange): dxrange = self.xrange / float(xrange) self.xrange = xrange xscaleorg = self.drawingarea.canvasx(self.botx/2) self.drawingarea.scale("a", xscaleorg, 0, dxrange, 1.0) self.drawingarea.scale("barsep", xscaleorg, 0, dxrange, 1.0) self.canx0 = xscaleorg + (self.canx0 - xscaleorg) * dxrange self.xscale = self.botx / float(self.xrange) self.setxscrollincrement(max(2, self.xscale)) self.drawxaxis() self.setscrollregion() def setxscrollincrement(self, dx): return self.drawingarea.configure(xscrollincrement=dx) self.xaxis.configure(xscrollincrement=dx) self.xmarks.configure(xscrollincrement=dx) def setyrange(self, yrange): dyrange = float(self.yrange) / yrange self.yrange = yrange self.var_yrange.set(yrange) self.drawingarea.scale("a", 0, 0, 1.0, dyrange) self.drawingarea.scale("barsep", 0, 0, 1.0, dyrange) self.yscale = float(self.boty) / self.yrange self.drawingarea.yview(MOVETO, 0.0) self.drawyaxis() def xscrollbar_set(self, first, last): self.xscrollbar.set(first, last) self.yrange_auto() def yrange_auto(self, force=0): if force or self.ycontrol.autovar.get(): lo = max(0, int(0.5+(self.drawingarea.canvasx(0) - self.canx0) / self.xscale)) hi = min(len(self.ymaxs), int(1.5+(self.drawingarea.canvasx(self.botx) - self.canx0) / self.xscale)) if lo == hi: ymax = 1 else: ymax = max(self.ymaxs[lo:hi]) if ymax != self.ymax: self.ymax = ymax self.ycontrol.fit(ymax) class MarkerControl: def __init__(self, master, marker, setcommand=lambda: 0 ): self.sample = 0 self.numsamples = 0 self.setcommand = setcommand self.marker = marker self.name = marker.name sf = self.frame = Frame(master, borderwidth=2, relief=GROOVE) self.samplevar = SizeVar() Label(sf, text='%s sample' % marker.name).grid(row=0, column=0) Label(sf, textvariable=self.samplevar, font=('terminal', '16', 'bold'), bg='black', fg='yellow' ).grid(row=1, column=0, padx=3, pady=3) ClickButton(sf, text='-', pady=0, padx=5, command=lambda: self.changesample(-1)).grid(row=0, column=1, sticky=E) ClickButton(sf, text='+', pady=0, padx=5, command=lambda: self.changesample(1)).grid(row=0, column=2, sticky=W) self.trackingvar = BooleanVar() self.trackbutton = Checkbutton( sf, text='Track', padx=5, variable=self.trackingvar, relief=RAISED, command=self.settracking, indicatoron=1, ) self.trackbutton.grid(row=1, column=1, columnspan=2) def changesample(self, d): sample = self.sample + d if 0 <= sample < self.numsamples: self.setmarker(sample) def setmarker(self, sample): self.marker.move(sample) self.setsample(sample) def setnumsamples(self, num): self.numsamples = num if self.trackingvar.get() or self.sample >= self.numsamples: self.setmarker(max(0, self.numsamples-1)) def setsample(self, sample): self.sample = sample self.samplevar.set(sample) self.setcommand() def settracking(self, tracking=None): if tracking is not None: self.trackingvar.set(tracking) else: tracking = self.trackingvar.get() if tracking: self.setmarker(max(0, self.numsamples-1)) class Window: def __init__(self, app, frame, windowmenu=None): self.app = app self.frame = frame self.windowmenu = windowmenu self.wtitle = frame.title() self._is_destroyed = 0 # Binding to <destroy> didnt work well: # frame.bind('<Destroy>', self.event_destroy, add='+') # I give up. I modify .destroy of frame argument instead. self.old_destroy = frame.destroy frame.destroy = self.new_destroy def new_destroy(self): if self._is_destroyed: return self._is_destroyed = 1 self.app.del_window(self) try: self.old_destroy() except TclError: # This may happen at closing last window # because exit destroys the root when it sees all windows were closed. # So I ignore it. pass def title(self, title): self.frame.title(title) self.frame.iconname(title) self.wtitle = title self.app.chg_window(self) def wakeup(self): frame = self.frame try: if frame.wm_state() == "iconic": frame.wm_deiconify() frame.tkraise() # I don't think I want .focus_set: it behaved strange in X at least. # frame.focus_set() except TclError: # This can happen when the window menu was torn off. # Simply ignore it. pass class WindowMenu: def __init__(self, frame, variable): self.button = Menubutton(frame, text='Window') self.menu = Menu(self.button) self.button['menu'] = self.menu self.variable = variable self.wmap = {} def add_window(self, window): self.menu.add_radiobutton( command=window.wakeup, label='%d %s' % (window.wid, window.wtitle), value=window.wid, variable=self.variable) self.wmap[window.wid] = self.menu.index(END) def chg_window(self, window): self.menu.delete(self.wmap[window.wid]) self.menu.insert_radiobutton( self.wmap[window.wid], command=window.wakeup, label='%d %s' % (window.wid, window.wtitle), value=window.wid, variable=self.variable) def del_window(self, window): idx = self.wmap[window.wid] del self.wmap[window.wid] try: self.menu.delete(idx) except TclError: # This can happen if the menu was destroyed before its contents. # Simply ignore it. pass for wid in list(self.wmap.keys()): if self.wmap[wid] > idx: self.wmap[wid] -= 1 class ProfileApp: def __init__(self, mod): self.mod = mod root = Tk() self.root = root root.withdraw() self.windows = {} self.windowmenus = {} self.var_window = IntVar(root) def add_window(self, window): window.wid = max([0]+list(self.windows.keys()))+1 self.windows[window.wid] = window wm = getattr(window, 'windowmenu', None) if wm: self.windowmenus[window.wid] = wm for w in list(self.windows.values()): if w is not window: wm.add_window(w) for wm in list(self.windowmenus.values()): wm.add_window(window) self.var_window.set(window.wid) window.frame.bind('<FocusIn>', lambda event: self.var_window.set(window.wid), add='+') window.frame.bind('<Deactivate>', lambda event: self.var_window.set(0), add='+') def add_window_frame(self, frame, windowmenu=None): w = Window(self, frame, windowmenu) self.add_window(w) return w def chg_window(self, window): for wm in list(self.windowmenus.values()): wm.chg_window(window) def del_window(self, window): wid = window.wid if getattr(window, 'windowmenu', None): del self.windowmenus[wid] del self.windows[wid] for wm in list(self.windowmenus.values()): wm.del_window(window) if not self.windows: self.exit() def exit(self): try: self.root.destroy() except TclError: pass self.root.quit() def mainloop(self): return self.root.mainloop() def new_profile_browser(self, filename): return ProfileBrowser(self, filename) class PaneDiv: def __init__(self, master, movecommand): self.frame = frame = Frame(master) self.movecommand = movecommand self.butsize = bs = 6 bc = self.butcent = bs / 2 + 3 h = 10 self.top = Canvas( frame, width=10, height=h, ) self.top.create_line( bc, 0, bc, h, fill='#808080', width=1) self.top.create_line( bc+1, 0, bc+1, h, fill='white', width=1) self.rsbut = Canvas( frame, cursor='crosshair', width=self.butsize, height=self.butsize, relief=RAISED, bd=2 ) self.bot = Canvas( frame, width=10, height=300, bd=0 ) self.top.grid(row=0, column=0, sticky=N) self.rsbut.grid(row=1, column=0, sticky=N) self.bot.grid(row=2, column=0, sticky=N) self.rsbut.bind('<Button-1>', self.but_down) self.rsbut.bind('<ButtonRelease-1>', self.but_up) def but_down(self, event): self.down_event = event self.rsbut.configure(relief=SUNKEN) def but_up(self, event): self.rsbut.configure(relief=RAISED) dx = event.x - self.down_event.x self.movecommand(dx) def setheight(self, height): h = height - 18 self.bot['height'] = h bc = self.butcent self.bot.create_line( bc, 0, bc, h, fill='#808080', width=1) self.bot.create_line( bc+1, 0, bc+1, h, fill='white', width=1) class TableFrame: def __init__(self, graph, master, numkindrows, samplevar): self.graph = graph self.mod = graph.mod frame = self.frame = Frame(master, borderwidth=2, relief=GROOVE) row = 0 self.marktime = StringVar() self.totsizevar = SizeVar() self.sampler = StringVar() self.sampler.set('R') fr = Frame(frame) # For header om = OptionMenu(fr, self.sampler, 'R', 'L', 'R-L') om.grid(row=0, column=0, sticky=W) Label(fr, text='Sample').grid(row=0, column=1, sticky=W) Label(fr, textvariable=samplevar, background='black', foreground='yellow', ).grid(row=0, column=2, sticky=W, pady=3) Label(fr, text='at').grid(row=0, column=3, sticky=W) Label(fr, textvariable=self.marktime).grid( row=0, column=4, sticky=W) Label(fr, text='Total size = ').grid( row=1, column=0, columnspan=3, sticky=W) Label(fr, textvar=self.totsizevar).grid( row=1, column=3, columnspan=2, sticky=W) fr.grid(row=row, column=0, sticky=W) row += 1 orow = row tb = Frame(frame) row = 0 Label(tb, text="").grid(row=row, column=0) Label(tb, text="R", ).grid(row=row, column=1, sticky=E) Label(tb, text="%R").grid(row=row, column=2, sticky=E) Label(tb, text="R-L", ).grid(row=row, column=3, sticky=E) Label(tb, text="%L").grid(row=row, column=4, sticky=E) Label(tb, text="Kind").grid(row=row, column=5, sticky=W) row += 1 self.profrows = [] self.totrow = ProfileRow(tb, row) self.profrows.append(self.totrow) row += 1 for i in range(numkindrows+1): profrow = ProfileRow(tb, row) self.profrows.append(profrow) row += 1 row = orow tb.grid(row=row, column=0, sticky=W) # for next.. row += 1 self.totresize = 0 self.kindwidth = ProfileRow.kindwidth def resize(self, dx, dy): dx = int(dx) self.totresize += dx charresize, extra = divmod(self.totresize, 7) newwidth = ProfileRow.kindwidth + charresize oldwidth = self.profrows[0].kind['width'] if newwidth < 10: newwidth = 10 dx = (newwidth - oldwidth) * 7 + extra for pr in self.profrows: pr.kind['width'] = newwidth pr.kindwidth = newwidth pr.kind['padx'] = extra / 2 import textwrap kindtext = textwrap.fill(pr.kindtext, width=pr.kindwidth) pr.set_kind(pr.kindtext) return dx, dy def update(self, lsamp, rsamp): self.marktime.set(self.mod.time.asctime( self.mod.time.localtime(rsamp.stat.timemade))) return for pr in self.profrows: pr.clear() rdiv = float(rsamp.stat.size) ldiv = float(lsamp.stat.size) self.totrow.set_color_size_percent_kind( None, rsamp.stat.size, 100.0, rsamp.stat.size - lsamp.stat.size, (rsamp.stat.size - lsamp.stat.size) * 100.0 / ldiv, '<Total>' ) for i, r in enumerate(rsamp.rows): l = lsamp.kindrows[r.name] self.profrows[i+1].set_color_size_percent_kind( self.graph.getkindcolor(r.name), r.size, r.size * 100.0 / rdiv, r.size - l.size, (r.size - l.size) * 100.0 / ldiv, r.name) class ColSpec: def __init__(self, tf, header, width, pos, render, idx=()): self.tf = tf self.header = header self.name = header self.width = width self.pos = pos self.render = render self.idx = idx def align(self, text): sp = ' '(self.width - len(text)) if self.pos == LEFT: text = text + sp elif self.pos == RIGHT: text = sp[:-1] + text + ' ' else: assert 0 assert len(text) == self.width return text class TableFrame: def __init__(self, graph, master): self.graph = graph self.mod = graph.mod frame = self.frame = Frame( master, borderwidth=3, relief=SUNKEN ) self.colspecs = {} self.colwidths = [] def defcol(names, width, pos, put, idxfunc=lambda x: ()): if callable(put): put = [put]len(names) self.colwidths.append(width) for name, put in zip(names, put): spec = ColSpec(self, name, width, pos, put, idxfunc(name)) self.colspecs[name] = spec defcol(('A', 'B'), 2, LEFT, self.putcolor, lambda x: x) defcol(('Size', 'Count'), 7, RIGHT, [self.putsize, self.putcount]) defcol(('%A:Tot', '%B:Tot'), 7, RIGHT, self.putpercent, lambda name: name[1]) defcol(('B-A', 'A-B', 'Cumul'), 7, RIGHT, [self.putdiff, self.putdiff, self.putcumul], lambda name: [(), name.split('-')]['-' in name]) defcol(('%A:Tot', '%B:Tot'), 7, RIGHT, self.putpercent, lambda name: name[1]) defcol(('Kind',), 20, LEFT, self.putkind) width = 0 for w in self.colwidths: width += w self.totxresize = 0 self.totyresize = 0 self.kindcol = self.colspecs['Kind'] self.orgkindwidth = self.kindcol.width self.widthbeforekind = width - self.orgkindwidth self.minkindwidth = 10 self.mintextheight = 2 width += 1 self.width = self.orgwidth = width wrap = NONE cursor = master['cursor'] relief = FLAT self.minpadx = 3 self.tothead = Text( frame, width=width, wrap=wrap, background='#ccc', height=2, padx=self.minpadx, relief=relief, cursor=cursor, ) self.rowhead = Text( frame, width=width, wrap=wrap, background='#ccc', height=1, padx=self.minpadx, relief=relief, cursor=cursor, ) self.tsframe = Frame(frame) self.textminpady = 2 self.text = Text( self.tsframe, width=width, wrap=wrap, height=21, background='#e0e0e0', relief=relief, takefocus=0, cursor=cursor, padx=self.minpadx, pady=self.textminpady, ) self.scrollbar = Scrollbar( self.tsframe, width=10, orient=VERTICAL, command=self.text.yview ) self.scrollbar_totwidth = int( self.scrollbar['width']) + 6 # width + padding self.uses_scrollbar = 0 self.auto_scrollbar = 1 self.orgtextheight = int(self.text['height']) padx = 0 pady = 0 self.tothead.pack(anchor=N+W, padx=padx, pady=pady) self.rowhead.pack(anchor=N+W, padx=padx, pady=pady) self.text.pack(side=LEFT, anchor=N+W, padx=padx, pady=pady) self.tsframe.pack(anchor=N+W, padx=padx, pady=pady) def setchdim(self): self.text.update() self.chdx = float(self.text.winfo_width()) / self.width self.chdy = float(self.text.winfo_height()) / self.orgtextheight self.chdx = int(round(self.chdx)) self.chdy = int(round(self.chdy)) self.pixwidth = self.width * self.chdx self.pixheight = self.width * self.chdy def putcolor(self, col): if self.colorow.name == '<Total>': text = col.align(' ') color = '#e0e0e0' else: color = self.graph.getkindcolor(self.colorow.name), text = col.align('@') self.text.insert('end', text, (color,)) self.text.tag_config(color, foreground=color, background='#e0e0e0', font=('terminal', '12', 'bold'),) def putcount(self, col): self.valmode = 'Count' count = self.colorow.count self.cumulval += count self.putval(col, count) def putsize(self, col): self.valmode = 'Size' size = self.colorow.size self.cumulval += size self.putval(col, size) def putval(self, col, val): self.curval = val self.ap(col.align(sizestring(val))) def putpercent(self, col): a = self.statbyname[col.idx] if self.valmode == 'Count': ref = a.count elif self.valmode == 'Size': ref = a.size if ref: ps = percentstring(self.curval * 100.0 / ref) else: ps = '---' self.ap(col.align(ps)) def putdiff(self, col): a, b = self.rowbyname[col.idx[0]], self.rowbyname[col.idx[1]] if self.valmode == 'Count': a, b = a.count, b.count elif self.valmode == 'Size': a, b = a.size, b.size self.putval(col, a - b) def putcumul(self, col): self.putval(col, self.cumulval) def putkind(self, col): # Must be last! import textwrap wraplines = textwrap.wrap(self.colorow.name, width=col.width) self.ap(col.align(wraplines[0])) if len(wraplines) > 1: initial = '\n'+' '(self.widthbeforekind) for line in wraplines[1:]: self.ap(initial+col.align(line)) def setmode(self, mode, numkindrows): self.mode = mode self.numkindrows = numkindrows self.mcontrols = self.graph.mcontrolbyname self.stats = self.graph.stats self.cols = [self.colspecs[x.strip()] for x in mode.split(' ') if x.strip()] self.controlnames = {} name = self.cols[0].idx self.colorcontrol = self.mcontrols[name] self.controlnames[name] = 1 self.controls = [self.colorcontrol] self.lastidxs = [None] for i, co in enumerate(self.cols): idx = co.idx if not isinstance(idx, (tuple, list)): idx = (idx,) for idx in idx: if idx not in self.controlnames: self.controls.append(self.mcontrols[idx]) self.controlnames[idx] = 1 self.lastidxs.append(None) def setscrollbar(self, sb): if sb == self.uses_scrollbar: return self.uses_scrollbar = sb w = self.scrollbar_totwidth if sb: self.resize(-w, 0, setscrollbar=0) self.scrollbar.pack(side=LEFT, fill=Y) self.text['yscrollcommand'] = self.scrollbar.set else: self.resize(w, 0, setscrollbar=0) self.scrollbar.pack_forget() self.text['yscrollcommand'] = None def update_simple(self, lsamp, rsamp): t = self.text t.delete('1.0', '100.0') t.insert('1.0', str(rsamp.stat)) def update(self, force=0, setscrollbar=1): stats = self.stats idxs = [max(0, min(control.sample, len(stats)-1)) for control in self.controls] if (idxs == self.lastidxs) and not force: return self.lastidxs = idxs self.text['state'] = self.tothead['state'] = self.rowhead['state'] = NORMAL self.text.delete('1.0', END) self.tothead.delete('1.0', END) self.rowhead.delete('1.0', END) if not stats: self.tothead.insert('end', '-- No Sample --') self.text['state'] = self.tothead['state'] = self.rowhead['state'] = DISABLED return self.statbyname = {} statbyidx = [] for i, control in enumerate(self.controls): stat = stats[idxs[i]] statbyidx.append(stat) self.statbyname[control.name] = stat samps = self.samps = [ Sample(self.mod, statbyidx[0], self.controls[0].marker.name, idxs[0], numkindrows=self.numkindrows, statype=self.graph.display.statype )] self.colorsamp = samps[0] if len(self.controls) > 1: samps.append(Sample(self.mod, statbyidx[1], self.controls[1].marker.name, idxs[1], relative=samps[0])) self.relsamp = samps[1] t = self.tothead n = max([len(str(samp.index)) for samp in samps]) for samp in samps: t.insert('end', 'Sample %s: ' % samp.name) t.insert('end', ('%%%dd' % n) % samp.index, ('index',)) t.insert('end', ' at %s\n' % (samp.datetime)) t.tag_configure('index', background='#e0e0e0') t = self.rowhead self.sizes = [float(samp.stat.size) for samp in samps] for col in self.cols: t.insert('end', col.align(col.header), ('header',)) t.insert('end', '\n') t = self.text self.ap = lambda text: t.insert('end', text) self.colorow = Row(samps[0].count, samps[0].size, '<Total>') self.rowbyname = self.statbyname self.cumulval = 0 for col in self.cols: col.render(col) self.ap('\n\n') self.cumulval = 0 for i, a in enumerate(samps[0].rows): self.colorow = a if len(samps) > 1: self.rowbyname = { samps[0].name: a, samps[1].name: samps[1].kindrows[a.name] } for col in self.cols: col.render(col) self.ap('\n') if setscrollbar and self.auto_scrollbar: numrows = int(self.text.index('end').split('.')[0])-2 h = int(self.text['height']) needs_scrollbar = numrows > h if needs_scrollbar != self.uses_scrollbar: self.setscrollbar(needs_scrollbar) self.text['state'] = self.tothead['state'] = self.rowhead['state'] = DISABLED def resize(self, dx, dy, setscrollbar=1): dx = int(dx) oldwidth = self.pixwidth newwidth = self.pixwidth + dx if newwidth < self.chdx 2: newwidth = self.chdx * 2 self.pixwidth = newwidth dx = newwidth - oldwidth charwidth, extra = divmod(newwidth, self.chdx) self.kindcol.width = max( charwidth - self.widthbeforekind - 1, self.minkindwidth) self.totxresize += dx for t in (self.tothead, self.rowhead, self.text): t['width'] = charwidth t['padx'] = self.minpadx + extra / 2 dy = int(dy) rowresize, extra = divmod(self.totyresize + dy, self.chdy) newheight = self.orgtextheight + rowresize oldheight = int(self.text['height']) if newheight < self.mintextheight: newheight = self.mintextheight dy = (newheight - oldheight) * self.chdy + extra self.totyresize += dy self.text['height'] = newheight self.text['pady'] = self.textminpady + extra / 2 self.update(force=1, setscrollbar=1) return dx, dy class Filler: def __init__(self, master): self.frame = self.can = Canvas( master, # background='blue', width=0, height=0) def getsize(self): return int(self.can['width']), int(self.can['height']), def setsize(self, w, h): self.can.configure( width=w, height=h ) def resize(self, dw, dh): w, h = self.getsize() self.setsize(max(0, w + dw), max(0, h + dh)) class Row: def __init__(self, count, size, name): self.count = count self.size = size self.name = name class Sample: def __init__(self, mod, stat, name, index, numkindrows=None, statype='Size', relative=None): self.stat = stat self.size = stat.size self.count = stat.count self.name = name self.index = index self.datetime = mod.time.asctime(mod.time.localtime(stat.timemade)) self.kindrows = {} if numkindrows is not None: rows = stat.get_rows_n_and_other(numkindrows, statype) for r in rows: self.kindrows[r.name] = r else: kinds = [] oidx = None for row in relative.rows: if row.name == '<Other>': oidx = len(kinds) continue else: kinds.append(row.name) rows = stat.get_rows_of_kinds(kinds) size = 0 count = 0 for i, row in enumerate(rows): kind = kinds[i] if row is None: row = Row(0, 0, kind) self.kindrows[kind] = row size += row.size count += row.count if oidx is not None: other = Row(stat.count - count, stat.size - size, '<Other>') rows[oidx:oidx] = [other] self.kindrows['<Other>'] = other self.rows = rows class ProfileBrowser: colors = ("red", "green", "blue", "yellow", "magenta", "cyan", 'white') numkindrows = 10 def __init__(self, app, filename): self.inited = 0 self.app = app self.mod = mod = app.mod self.master = master = app.root if filename: filename = mod.path.abspath(filename) self.initialdir = mod.path.dirname(filename) else: self.initialdir = mod.os.getcwd() self.frame = frame = Toplevel( master, # background='#bbb' ) #frame['cursor'] = 'umbrella' # frame.resizable(True,True) self.menubar = Frame(self.frame, relief=RAISED, bd=2) self.filebutton = Menubutton(self.menubar, text='File') self.filemenu = Menu(self.filebutton) self.filebutton['menu'] = self.filemenu self.filemenu.add_command( label='New Profile Browser', command=self.cmd_new) self.filemenu.add_command(label='Open Profile', command=self.cmd_open) self.filemenu.add_command(label='Close Window', command=self.cmd_close) self.filemenu.add_command( label='Clear Cache', command=self.cmd_clear_cache) self.filemenu.add_command(label='Exit', command=self.cmd_exit) self.panebutton = Menubutton(self.menubar, text='Pane') self.panemenu = Menu(self.panebutton) self.panebutton['menu'] = self.panemenu choices = [ ('Bars', 'Lines'), ('Size', 'Count'), ] self.graphtypevar = StringVar() self.graphbutton = self.modechooser( self.menubar, 'Graph', choices, self.graphtypevar, self.cmd_graphtype) choices = [ ('A', 'B'), ('Size', 'Count'), ('%A:Tot', '%B:Tot'), ('Cumul', 'A-B', 'B-A'), ('%A:Tot', '%B:Tot'), ('Kind',), ] self.var_tablemode = StringVar() self.tablebutton = Menubutton(self.menubar, text='Table') self.tablemenu = Menu(self.tablebutton) self.tablebutton['menu'] = self.tablemenu self.headermenu = Menu(self.tablebutton, title='Table header') self.addmodechooser( self.headermenu, choices, self.var_tablemode, self.cmd_tablemode ) self.tablemenu.add_cascade(label='Header', menu=self.headermenu) self.var_tablescrollbar = StringVar() self.tablescrollbarmenu = Menu( self.tablebutton, title='Table scrollbar') self.addmodechooser( self.tablescrollbarmenu, [('Auto', 'On', 'Off')], self.var_tablescrollbar, self.cmd_tablescrollbar ) self.tablemenu.add_cascade( label='Scrollbar', menu=self.tablescrollbarmenu) self.windowmenu = WindowMenu(self.menubar, self.app.var_window) self.window = app.add_window_frame(self.frame, self.windowmenu) self.helpbutton = Menubutton(self.menubar, text='Help') self.helpmenu = Menu(self.helpbutton) self.helpbutton['menu'] = self.helpmenu self.helpmenu.add_command(label='About', command=self.cmd_about) self.helpmenu.add_command(label='Help', command=self.cmd_help) self.ctrlframe = Frame( self.frame, bd=2, relief=GROOVE, # background='#999', ) self.exitbutton = Button(self.ctrlframe, text='Exit', command=self.cmd_exit, background='red') self.set_filename(filename) self.id_collect = None self.collecting = IntVar() self.collecting.set(0) self.collectbutton = Checkbutton(self.ctrlframe, text='Collect', variable=self.collecting, command=self.cmd_collect, relief=RAISED) self.stats = Stats(self.mod) self.disptab = Frame(self.frame, # relief=SUNKEN, # bd=3 ) self.display = Display(self.disptab, scale_table=AxisControl.scale_table, numkindrows=self.numkindrows, getkindcolor=self.getkindcolor, ) self.xcontrol = AxisControl(self.ctrlframe, name='X', range=self.display.xrange, grid=self.display.xgrid, unit='samples', rangecommand=self.display.setxrange, gridcommand=self.display.setxgrid ) self.ycontrol = AxisControl(self.ctrlframe, name='Y', range=self.display.yrange, grid=self.display.ygrid, unit='bytes', rangecommand=self.display.setyrange, gridcommand=self.display.setygrid, autocommand=self.display.cmd_yrange_auto ) self.display.xcontrol = self.xcontrol self.display.ycontrol = self.ycontrol self.mcontrols = [] self.mcontrolbyname = {} for name in ('A', 'B'): marker = self.display.new_xmarker(name) control = MarkerControl( self.ctrlframe, marker, self.update_tableframe) marker.set_poscommand(control.setsample) self.mcontrols.append(control) self.mcontrolbyname[name] = control self.var_showcontrol = BooleanVar() self.var_showcontrol.set(1) self.panemenu.add_checkbutton( label='Show Control Panel', variable=self.var_showcontrol, command=self.cmd_showcontrol) self.var_showgraph = BooleanVar() self.var_showgraph.set(1) self.panemenu.add_checkbutton( label='Show Graph', variable=self.var_showgraph, command=self.cmd_showgraph) self.var_showtable = BooleanVar() self.var_showtable.set(1) self.panemenu.add_checkbutton( label='Show Table', variable=self.var_showtable, command=self.cmd_showtable) tf = self.tf = TableFrame(self, self.disptab) d_t = self.d_t = PaneDiv(self.disptab, movecommand=self.cmd_dt_moved) self.xcontrol.frame.grid(row=0, column=0, padx=3, pady=3, sticky=W) self.ycontrol.frame.grid(row=1, column=0, padx=3, pady=3) self.mcontrols[0].frame.grid( row=0, column=1, columnspan=1, sticky=W, padx=3, pady=3) self.mcontrols[1].frame.grid( row=1, column=1, columnspan=1, sticky=W, padx=3, pady=3) self.exitbutton.grid(row=0, column=2, padx=3, pady=3) self.collectbutton.grid(row=0, column=3, padx=3, pady=3) self.filler = Filler(self.frame) self.filebutton.pack(side=LEFT) self.panebutton.pack(side=LEFT) self.graphbutton.pack(side=LEFT) self.tablebutton.pack(side=LEFT) self.windowmenu.button.pack(side=LEFT) self.helpbutton.pack(side=LEFT) self.menubar.grid(column=0, columnspan=4, sticky=N+W+E) self.gridmain() frame.bind('<Map>', self.event_map) self.tf.setmode(self.var_tablemode.get(), self.numkindrows) self.load_filename(filename) d_t.frame.update_idletasks() d_t.setheight(max(self.display.frame.winfo_height(), tf.frame.winfo_height())) d_t.frame.update_idletasks() self.minsize = (500, 400) self.maxsize = (self.frame.winfo_screenwidth(), self.frame.winfo_screenheight()) minsizes = { # (ctrl, disp, tab) : (width, height) (0, 0, 0): (270, 25), (1, 0, 0): (363, 61), (0, 1, 0): (270, 131), (1, 1, 0): (270, 131), } self.setusergeometry() def initfinal(): self.tf.setchdim() rx = self.frame.winfo_rootx() + self.frame.winfo_width() self.tf_wanted_margin = rx - \ (self.tf.frame.winfo_rootx() + self.tf.frame.winfo_width()) self.lastw = self.frame.winfo_width() self.lasth = self.frame.winfo_height() self.in_configure = 0 frame.bind('<Configure>', self.event_configure) self.inited = 1 initfinal() # self.frame.after_idle(initfinal) def cmd_about(self): self.cmd_help('about') def cmd_help(self, pickname='help'): os = self.mod.os ocursor = self.frame.winfo_toplevel()['cursor'] try: self.frame.winfo_toplevel()['cursor'] = 'watch' self.frame.update() m = self.mod.Text.gsltextviewer( self.frame, inpickle=getattr(self.mod.pbhelp, pickname) # htmloutfile='/tmp/x.html', ) self.app.add_window_frame(m) finally: self.frame.winfo_toplevel()['cursor'] = ocursor def cmd_clear_cache(self): self.stats.clear_cache() def cmd_close(self): self.frame.destroy() def cmd_collect(self, args): # self.afterfunc() # self.frame.after(1, self.afterfunc) # Turn on button first.?? if self.collecting.get(): self.event_collect() else: if self.id_collect is not None: self.frame.after_cancel(self.id_collect) self.id_collect = None def event_collect(self): o, n = self.stats.collect() if n: if o != self.display.numstats: self.display.load_stats(self.stats) else: st = self.stats[-n:] self.display.add_stats(st) for c in self.mcontrols: c.setnumsamples(len(self.stats)) self.id_collect = self.frame.after(1000, self.event_collect) def cmd_dt_moved(self, dx): # The division between display and table panes moved. # Disable configure event handling while we are resizing. self.in_configure += 1 # Right x position of enclosing frame rx = self.frame.winfo_rootx() + self.frame.winfo_width() # Right margin between pane divider and enclosing window mx = rx - (self.d_t.frame.winfo_rootx() + self.d_t.frame.winfo_width()) # Don't move pane divider outside window dx = min(dx, mx) # Right margin between table and enclosing window # before resizing mx = rx - (self.tf.frame.winfo_rootx() + self.tf.frame.winfo_width()) dx, _ = self.display.resize(dx, 0) wanted_margin = self.tf_wanted_margin # After move mx -= dx self.tf.resize(mx - wanted_margin, 0) self.display.moveback() self.in_configure -= 1 def cmd_exit(self): self.app.exit() def cmd_graphtype(self): self.display.setgraphtype(self.graphtypevar.get(), self.stats) self.cmd_tablemode() def cmd_new(self): self.app.new_profile_browser(self.filename) def cmd_open(self): op = tkinter.filedialog.Open(self.frame, # ? Should we have default extension or not?? # defaultextension='.hpy', initialdir=self.initialdir, filetypes=[('Heapy data files', '.hpy'), ('All files', '') ] ) filename = op.show() if filename: self.load_filename(filename) def cmd_showcontrol(self): self.grid_things() def cmd_showgraph(self): if self.var_showgraph.get() and self.var_showtable.get(): self.tf.resize(-self.tf.totxresize, 0) self.display.resize(self.display.orgwidth - self.display.botx, 0) self.display.moveback() self.grid_things() cmd_showtable = cmd_showgraph def cmd_tablemode(self): self.tf.setmode(self.var_tablemode.get(), self.numkindrows) self.tf.update() def cmd_tablescrollbar(self): tf = self.tf s = self.var_tablescrollbar.get() if s == 'Auto': tf.auto_scrollbar = 1 tf.update(force=1, setscrollbar=1) elif s == 'On': tf.auto_scrollbar = 0 tf.setscrollbar(1) elif s == 'Off': tf.auto_scrollbar = 0 tf.setscrollbar(0) else: assert 0 def setusergeometry(self): # Make the geometry of the window be user-specified # This is called after Tk has determined the size # of the window needed for the initial widget configuration. # The size is not to be changed after that, other than # on user request. # I couldn't just do frame.geometry(frame.geometry()) because, # presumably, of a bug in the Tk and/or wm I am using. I hope # this works for all systems .. Notes 26 Oct 2005. self.frame.update() g = '%dx%d+%d+%d' % ( self.frame.winfo_width(), self.frame.winfo_height(), self.frame.winfo_rootx(), self.frame.winfo_rooty()) self.frame.geometry(g) def modechooser(self, frame, name, choices, cmdvar, command): button = Menubutton(frame, text=name) menu = Menu(button) button['menu'] = menu self.addmodechooser(menu, choices, cmdvar, command) return button def addmodechooser(self, menu, choices, cmdvar, command): def setcmdvar(): cmdvar.set(' '.join([v.get() for v in vars])) def cmd(): setcmdvar() command() vars = [] for ch in choices: var = StringVar() vars.append(var) var.set(ch[0]) for a in ch: menu.add_radiobutton( command=cmd, label=a, value=a, variable=var, #font=('Courier','12', 'bold'), #font=('Helvetica','12', 'bold'), columnbreak=(a == ch[0]) ) setcmdvar() def grid_things(self): ow = self.frame.winfo_width() oh = self.frame.winfo_height() self.ctrlframe.grid_forget() self.display.frame.grid_forget() self.d_t.frame.grid_forget() self.tf.frame.grid_forget() self.disptab.grid_forget() self.filler.frame.grid_forget() self.gridmain() self.frame.update_idletasks() self.sizewidgets() def gridmain(self): row = 1 c = self.var_showcontrol.get() if c: self.ctrlframe.grid(row=row, column=0, columnspan=3, padx=3, pady=3, sticky=W) row += 1 column = 0 g = self.var_showgraph.get() t = self.var_showtable.get() gt = (g, t) if g: self.display.frame.grid(row=0, column=column, sticky=N+W, padx=3, pady=3 ) column += 1 if g and t: self.d_t.frame.grid(row=0, column=column, sticky=N+W) column += 1 if t: self.tf.frame.grid(row=0, column=column, sticky=N+W, padx=3, pady=3 ) if g or t: self.disptab.grid(row=row, column=0, sticky=N+W, # padx=3,pady=3, ) row += 1 self.filler.setsize(0, 0) self.filler.frame.grid(row=row, column=3, sticky=N+W) self.frame.resizable(1, 1) def event_configure(self, event): if event.widget is not self.frame: return if not self.inited: return if self.in_configure: return curw = self.frame.winfo_width() curh = self.frame.winfo_height() if curw == self.lastw and curh == self.lasth: return self.in_configure += 1 self.lastw = curw self.lasth = curh self.sizewidgets() self.in_configure -= 1 def sizewidgets(self): self.frame.update() curw = self.frame.winfo_width() curh = self.frame.winfo_height() mbx = self.menubar.winfo_rootx() mby = self.menubar.winfo_rooty() sfs = [] if self.var_showgraph.get(): sfs.append(self.display) if self.var_showtable.get(): sfs.append(self.tf) if not sfs: sfs.append(self.filler) dys = {} didh = 0 for sf in sfs: f = sf.frame diy = f.winfo_rooty() dih = f.winfo_height() ch = diy - mby + dih dy = curh - ch - 7 didh = didh or dy dys[sf] = dy if self.var_showtable.get(): f = self.tf.frame elif self.var_showgraph.get(): f = self.display.frame else: f = self.filler.frame fx = f.winfo_rootx() fw = f.winfo_width() cw = fx - mbx + fw fdw = curw - cw - 6 if f is self.filler.frame and not self.var_showcontrol.get(): fdw = curw - self.filler.getsize()[0] - 3 if didh or fdw: if self.var_showgraph.get() and self.var_showtable.get(): dprop = float(self.display.frame.winfo_width()) dprop = dprop / (dprop + self.tf.frame.winfo_width()) dx, dy = self.display.resize(fdw * dprop, dys[self.display]) self.tf.resize(fdw - dx, dys[self.tf]) self.frame.update_idletasks() self.d_t.setheight(max(self.display.frame.winfo_height(), self.tf.frame.winfo_height())) elif self.var_showgraph.get(): self.display.resize(fdw, dys[self.display]) elif self.var_showtable.get(): self.tf.resize(fdw, dys[self.tf]) else: self.filler.resize(fdw, dys[self.filler]) self.filler.setsize(self.filler.getsize()[0], 1000) if self.var_showgraph.get(): self.display.moveback() #self.resize(dw, dh) def resize(self, dw, dh): self.display.resize(dw, dh) # self.frame.wm_geometry('') def event_map(self, event): self.frame.unbind('<Map>') self.frame.bind('<Unmap>', self.event_unmap) self.frame.lift() def event_unmap(self, event): self.frame.unbind('<Unmap>') self.frame.bind('<Map>', self.event_map) def load_filename(self, filename): ocursor = self.frame.winfo_toplevel()['cursor'] try: self.frame.winfo_toplevel()['cursor'] = 'watch' self.frame.update() if filename: filename = self.mod.path.abspath(filename) try: self.stats.open(filename) except Exception: __import__('traceback').print_exc() etype, value, tb = self.mod._root.sys.exc_info() tkinter.messagebox.showerror( master=self.frame, message=( "Error when loading\n%r:\n" % filename + "%s" % ''.join(self.mod._root.traceback.format_exception_only( etype, value))) ) else: self.display.load_stats(self.stats) for c in self.mcontrols: c.setnumsamples(len(self.stats)) # self.scontrol.trackcommand(1) self.set_filename(filename) self.xrange_fit() self.display.xview_moveto(0) self.mcontrols[1].settracking(0) self.mcontrols[0].settracking(1) self.yrange_fit() self.tf.update(force=1) if filename: self.initialdir = self.mod.path.dirname(filename) finally: self.frame.winfo_toplevel()['cursor'] = ocursor def update_tableframe(self): self.tf.update() def getkindcolor(self, kind): if kind == '<Other>': return 'black' else: return self.colors[abs(hash(kind)) % len(self.colors)] def set_filename(self, filename): self.filename = filename if not filename: filename = '<No File>' title = 'Heapy Profile Browser: %s' % filename self.window.title(title) def setnormpos(self): self.setscrollregion() if self.ymax >= self.yrange: self.yrange_fit() if self.xi0 is None: self.drawxaxis() else: self.updatexaxis() self.track() def redraw_all(self): pass def trackoff(self): self.rcontrol.settracking(0) def xrange_fit(self): self.xcontrol.fit(len(self.stats)) def yrange_fit(self): self.display.yrange_auto(force=1) class _GLUECLAMP_: _imports_ = ( '_parent:Use', '_parent:pbhelp', '_root.guppy.etc:textView', '_root:hashlib', '_root:os', '_root.os:path', '_root:time', '_root.guppy.gsl:Text', ) def pb(self, filename=None): """pb( [filename: profilefilename+]) Create a Profile Browser window. Argument filename: profilefilename+ The name of a file containing profile data. See also Heapy Profile Browser[1] Screenshot[2] References [0] heapy_Use.html#heapykinds.Use.pb [1] ProfileBrowser.html [2] pbscreen.jpg""" pa = ProfileApp(self) pa.new_profile_browser(filename) pa.mainloop() def tpg(self): self('/tmp/x.hpy')	90.38 KB	2026-01-20 12:58
📄 RM.py # Start a remote monitoring enabling thread, # unless I am that thread myself. from guppy.heapy.Remote import on on()	119 B	2026-01-20 12:58
📄 RefPat.py def str_as_atr(s): if s == '_': return [] atr = [] i = 0 while i < len(s): v = s[i] if i + 1 < len(s) and s[i+1].isdigit(): n = 0 i = i + 1 while i < len(s) and s[i].isdigit(): n = n * 10 + int(s[i]) i += 1 else: i += 1 n = 1 for j in range(n): atr.append(v) return atr def atr_as_str(atr): if not atr: return '_' prefl = [] prestr = ''.join([str(x) for x in atr]) i = 0 while i < len(prestr): c = prestr[i] j = i+1 while j < len(prestr) and prestr[j] == c: j += 1 if j - i > 2: prefl.append(c) prefl.append(str(j-i)) else: while i < j: prefl.append(c) i += 1 i = j return ''.join(prefl) def str_as_ixl(s): return [ord(ch)-ord('a') for ch in str_as_atr(s)] def ixl_as_str(ixl): return atr_as_str([chr(ix + ord('a')) for ix in ixl]) class Paths: def __init__(self, mod, rp, key, extended=True, andsets=(), variant=2): self.mod = mod self._hiding_tag_ = mod._hiding_tag_ self.key = key self.rp = rp self.extended = extended self.srcrow = rp.get_row(self.key) self.variant = variant self.andsetbyname = {} row = self.srcrow while row is not None: self.andsetbyname[row.ixlstr] = mod.Use.Anything row = row.parent if isinstance(andsets, dict): self.andsetbyname.update(andsets) elif isinstance(andsets, (tuple, list)): row = self.srcrow for i, s in enumerate(andsets): if row is None: raise ValueError('andsets argument is too long') if s is not None: self.andsetbyname[row.ixlstr] = s row = row.parent else: raise TypeError('andsets argument must be dict, tuple, or list') mod.OutputHandling.setup_printing( self, stop_only_when_told=variant >= 2) def get_str_of_path_component_singleton(self, set): return set.brief.lstrip('<1 ').rstrip('>') def source_to_target_info(self): src = 'Source' tgt = 'Target' via = 'Via' row = self.srcrow indent = 0 while row is not None: if row.parent is None: a = tgt elif row is srcrow: a = src else: a = via a = ' 'indent + a name = row.ixlstr a = a + ' ' + ' '(8+srcrow.depthindinc - len(name)-len(a)) + name + ': ' yield a+row.getsummary(mod.line_length-len(a)) row = row.parent indent += indinc def _oh_get_label(self): return 'Paths from source %r to target %r.' % (self.srcrow.ixlstr, '_') def _oh_get_line_iter(self): return getattr(self, 'get_line_iter_%s' % (self.variant,))() def _oh_get_more_state_msg(self, startindex, lastindex): return '' def get_line_iter_1(self): # Original variant indenting from left to right mod = self.mod srcrow = self.srcrow srcset = srcrow.set indinc = 2 if srcrow.depth >= 10: indinc = 1 def genlines(row, ks, indent=0): par = row.parent for key, i, set in ks: sidx = '%s[%d]' % (row.ixlstr, i) if self.extended: strsing = self.get_str_of_path_component_singleton(set) else: strsing = '' vline = '%s %s %s %s' % ( key, ' '(40-len(key) - len(sidx)), sidx, strsing ) yield vline if par is None: continue def get_nks(key, set): parset = set.referents & par.set for i, p in enumerate(parset.byid.parts): rels = mod.Path.relations(set.theone, p.theone) for rel in rels: if rel is mod.Path.identity: continue if rel is mod.Path.norelation: k = '??' else: k = str(rel) % '' k = ' '(indent+indinc)+k yield k, i, p for line in genlines(par, get_nks(key, set), indent+indinc): yield line def get_ks(): for i, s in enumerate(srcset.byid.parts): k = '[%d] ' % i k = k + (' -'20)[:36-len(k)-srcrow.depth] yield k, i, s for line in genlines(srcrow, get_ks()): yield line return def get_line_iter_2(self): # Newer variant mod = self.mod srcrow = self.srcrow indinc = 1 if srcrow.depth >= 10: indinc = 1 lno = [0] seen = {} indir = 1 if indir == 1: max_ixlstr_len = 0 max_str_len_set = 0 row = srcrow while row: if len(row.ixlstr) > max_ixlstr_len: max_ixlstr_len = len(row.ixlstr) if len(str(len(row.set.nodes))) > max_str_len_set: max_str_len_set = len(str(len(row.set.nodes))) row = row.parent def genlines(row, part, idx): seen[part.nodes, row.depth] = lno[0] sidx = row.ixlstr idxs = '[%d]' % idx if indir < 0: indent = (row.depth)indinc sidx = '%s%s%s' % ( sidx, ' '(6+indent-len(sidx)-len(idxs)), idxs) if row.parent is None: sidx += ' == %s' % part.brief else: #idxs = ('[%.'+str(max_str_len_set)+'d]')%idx sidx = '%s%s%s' % (sidx, ' '(3+max_str_len_set + max_ixlstr_len-len(sidx)-len(idxs)), idxs) sidx += ' ' (srcrow.depth + 1 - row.depth) if row.parent is not None: sidx += '@' else: sidx += '= %s' % part.brief if row.parent is None: #vline += ' == %s'%self.get_str_of_path_component_singleton(part) vline = '%2s: %s' % (lno[0], sidx) lno[0] += 1 yield ('STOP_AFTER', vline) return referents = part.referents & row.parent.set & self.andsetbyname[row.parent.ixlstr] relations = mod.Path.relations iso = mod.Use.iso s = part.theone t = [(relations(s, p.theone), p.by(referents.er), i) for (i, p) in enumerate(referents.byid.parts)] for (rels, p, i) in t: relstrings = [] for rel in rels: if rel is mod.Path.identity: continue if rel is mod.Path.norelation: k = '??' else: k = str(rel) % '' relstrings.append(k) relsstr = ' / '.join(relstrings) seenlno = seen.get((p.nodes, row.parent.depth)) vline = '%2s: %s' % (lno[0], sidx) lno[0] += 1 if seenlno is not None: relsstr += ' -> #%d' % seenlno yield ('STOP_AFTER', vline + ' ' + relsstr) else: yield vline + ' ' + relsstr for line in genlines(row.parent, p, i): yield line for i, p in enumerate((srcrow.set & self.andsetbyname[srcrow.ixlstr]).byid.parts): for line in genlines(srcrow, p, i): yield line class RefPatIter: def __init__(self, rp, start=0): self.rp = rp self._hiding_tag_ = rp._hiding_tag_ self.ix = start def __iter__(self): return self def __next__(self): try: x = self.rp[self.ix] except IndexError: raise StopIteration self.ix += 1 return x class RefPatRow: def __init__(self, rp, kindset, seenline, ixl, parent): self.rp = rp self._hiding_tag_ = rp._hiding_tag_ self.kindset = kindset self.kind, self.set = kindset assert self.set <= self.kind self.seenline = seenline self.ixl = ixl[:] self.parent = parent if parent is not None: self.depth = parent.depth + 1 else: self.depth = 0 self.index = 0 self.maxdepth = rp.depth self.max_str_len = rp.mod.line_length self.ixlstr = ixl_as_str(ixl) self.isready = 0 self.children = [] def __str__(self): prestr = '%2d: %s ' % (self.index, self.ixlstr) if self.index & 1: fillpat = ' ' * 100 else: fillpat = '-'100 lps = len(prestr) fill = fillpat[lps:9+self.depth] if self.seenline: ref = '[^ %s]' % self.seenline.index elif self.isroot: ref = '[R]' elif self.depth > 0 and self.set <= self.rp.stopkind: ref = '[S]' elif self.depth < self.maxdepth: ref = '[-]' else: ref = '[+]' prefix = '%s%s %s ' % (prestr, fill, ref) return '%s%s' % (prefix, self.getsummary(self.max_str_len-len(prefix))) def getchild(self, ix): while ix >= len(self.children) and not self.isready: self.rp.generate(len(self.rp.lines)) return self.children[ix] def getsummary(self, max_len): kind, set = self.kind, self.set summary = set.fam.get_str_refpat(set, kind, max_len) return summary class ReferencePattern: __doc__ = '<Help Text' help = """\ Methods """ def __init__(self, mod, set, depth, er, relimg, bf, stopkind, nocyc): self.mod = mod self._hiding_tag_ = mod._hiding_tag_ self.View = mod.View self.set = set self.depth = depth self.er = er self.bf = bf self.stopkind = stopkind self.nocyc = nocyc self.is_initialized = 0 self.totcount = set.count self.totsize = set.indisize self.kind = set.kind self.kindset = (self.kind, self.set) self.relimg = relimg self.top = self mod.OutputHandling.setup_printing(self) self.View.referrers_add_target(self) self.reset_nogc() self.is_initialized = 1 def __getattr__(self, s): if not self.is_initialized: raise AttributeError(s) try: return getattr(self.__class__, s) except AttributeError: pass try: row = self.get_row_named(s) except ValueError: raise AttributeError(s) return row.set def __getitem__(self, ix): return self.get_row_indexed(ix).set def __iter__(self, start=0): return RefPatIter(self, start) def __len__(self): self.generate() return len(self.lines) def _oh_get_label(self): return 'Reference Pattern by <' + self.er.classifier.get_byname() + '>.' def _oh_get_more_state_msg(self, startindex, lastindex): if self.isfullygenerated: msg = '%d more lines. ' % (len(self.lines) - 1-lastindex,) else: msg = '' return msg def _oh_get_line_iter(self): it = self.iterlines(0) for el in it: yield str(el) def generate(self, ix=None): while ix is None or ix < 0 or ix >= len(self.lines): try: self.lines.append(next(self.lg)) except StopIteration: self.isfullygenerated = 1 return self.lines[-1].index = len(self.lines) - 1 def get_row(self, key): try: [][key] except TypeError: return self.get_row_named(key) except IndexError: return self.get_row_indexed(key) def get_row_indexed(self, ix): self.generate(ix) return self.lines[ix] def get_row_named(self, name): row = self.get_row_indexed(0) for ix in str_as_ixl(name): try: row = row.getchild(ix) except IndexError: raise ValueError( 'Reference pattern has no row named %r' % name) return row def iterlines(self, start=None): if start is None: start = 0 while 1: try: yield self.get_row_indexed(start) except IndexError: return start += 1 def linegenerator(self, xxx_todo_changeme, ixl, parent=None): (kind, set) = xxx_todo_changeme seenline = self.seensets.get(set.nodes) ixl = list(ixl) line = RefPatRow(self, (kind, set), seenline=seenline, ixl=ixl, parent=parent) children = self.get_children(line) line.isroot = not children if seenline is None: self.seensets[set.nodes] = line if parent is not None: parent.children.append(line) yield line depth = line.depth if (not seenline and depth < self.depth and (depth == 0 or not (set <= self.stopkind))): for i, cs in enumerate(children): ixl.append(i) for rl in self.linegenerator(cs, ixl, line): yield rl ixl.pop() line.isready = 1 def get_children(self, line): (kind, set) = line.kindset chset = self.relimg(set) if self.nocyc: while line is not None: chset -= line.set line = line.parent return [(row.kind, row.set) for row in self.get_partition(chset, self.er).get_rows()] def get_partition(self, set, er): p = self.mod.Part.partition(set, er) return p def paths(self, key, kwds): return Paths(self.mod, self, key, *kwds) def reset(self): self.reset_nogc() self.printer.reset() self.mod._root.gc.collect() def reset_nogc(self): self.isfullygenerated = 0 self.seensets = {} self.lines = [] self.lg = self.linegenerator(self.kindset, []) self.lastindex = None class _GLUECLAMP_: _preload_ = ('_hiding_tag_',) depth = 7 line_length = 80 _uniset_exports = ('rp',) _chgable_ = ('er', 'depth', 'line_length', ) # 'module imports' _imports_ = ( '_parent:OutputHandling', '_parent:Part', '_parent:Path', '_parent:UniSet', '_parent:Use', '_parent:View', '_parent.View:_hiding_tag_', ) # def _get_er(self): return self.Use.Clodo def _get_stopkind(self): hp = self.Use return ( hp.Type.Module \| hp.Type.Type \| hp.Type.Module.dictof \| hp.Type.Type.dictof \| hp.Type.Code \| hp.Type.Frame ) def rp(self, X, depth=None, er=None, imdom=0, bf=0, src=None, stopkind=None, nocyc=False, ref=None): """rp(X, depth=None, er=None, imdom=0, bf=0, src=None, stopkind=None, nocyc=False, ref=None) Reference pattern forming. Arguments X Set of objects for which a reference pattern is sought. depth The depth to which the pattern will be generated. The default is taken from depth of this module. er The equivalence relation to partition the referrers. The default is Clodo. imdom If true, the immediate dominators will be used instead of the referrers. This will take longer time to calculate, but may be useful to reduce the complexity of the reference pattern. bf If true, the pattern will be printed in breadth-first order instead of depth-first. (Experimental.) src If specified, an alternative reference source instead of the default root. stopkind nocyc ref Description Return a reference pattern object based on the objects in the set X. The reference pattern object is of class ReferencePattern. It is described in XXX. """ if depth is None: depth = self.depth X = self.UniSet.idset_adapt(X) if src is not None: # Creates an entire new guppy tree # Mostly for testing purposes - # can likely cause type problems generally src = self.UniSet.idset_adapt(src) self = self._root.guppy.Root().guppy.heapy.RefPat self.View.root = tuple(src.nodes) X = self.Use.idset(X.nodes) if er is None: er = self.er # NEEDS to be loaded after new Classifier created if imdom: def relimg(X): return X.imdom elif ref is not None: if ref == 'gc': def relimg(X): return X.referrers_gc elif ref == 'gcx': relimg = (lambda x: x.referrers_gc - self._root.guppy.sets.ImmNodeSet - self._parent.heapyc.NodeGraph - self.View.ObservationList) elif ref == 'imdom': def relimg(X): return X.imdom elif callable(ref): relimg = ref else: raise ValueError( "ref should be 'gc', 'gcx', 'imdom', or a callable") else: def relimg(X): return X.referrers if stopkind is None: stopkind = self.stopkind rp = ReferencePattern(self, X, depth, er, relimg, bf, stopkind, nocyc) return rp	18.18 KB	2026-01-20 12:58
📄 Remote.py """ Support remote access to a Python interpreter. """ from guppy.etc import cmd from guppy import hpy from guppy.heapy import heapyc, Target from guppy.heapy.RemoteConstants import * from guppy.heapy.Console import Console from guppy.sets import mutbitset import atexit import io import queue import select import socket import sys import time import _thread import threading import traceback class SocketClosed(Exception): pass class IsolatedCaller: # Isolates the target interpreter from us # when the _hiding_tag_ is set to the _hiding_tag_ of our hp. # A solution of a problem discussed in notes Nov 8-9 2005. # Note feb 3 2006: The class in the Target instance must be used. def __init__(self, func): self.func = func def __call__(self, args, kwds): return self.func(args, *kwds) class QueueWithReadline(queue.Queue): def readline(self, size=-1): # Make sure we are interruptible # in case we get a keyboard interrupt. # Not a very elegant way but the 'only' there is? while 1: try: return self.get(timeout=0.5) except queue.Empty: continue class InterruptableSocket: def __init__(self, backing): self._backing = backing self.fileno = self._backing.fileno self.close = self._backing.close self.readable = self._backing.readable self.writable = self._backing.writable self.seekable = self._backing.seekable @property def closed(self): return self._backing.closed def read(self, size=-1): while not select.select([self], [], [], 0.5)[0]: pass return self._backing.read(size) class NotiInput: def __init__(self, input, output): self.input = input self.output = output def read(self, size=-1): # This may return less data than what was requested return self.readline(size) def readline(self, size=-1): self.output.write(READLINE) return self.input.readline(size) class Annex(cmd.Cmd): address_family = socket.AF_INET socket_type = socket.SOCK_STREAM use_rawinput = 0 prompt = '<Annex> ' def __init__(self, target, port=None): cmd.Cmd.__init__(self) if port is None: port = HEAPYPORT self.server_address = (LOCALHOST, port) self.target = target target.close = target.sys.modules['guppy.heapy.Remote'].IsolatedCaller( # target.close = IsolatedCaller( self.asynch_close) self.socket = None self.isclosed = 0 self.closelock = _thread.allocate_lock() self.intlocals = { } self.do_reset('') def asynch_close(self): # This may be called asynchronously # by some other thread than the current (annex) thread. # So I need to protect for a possible race condition. # It is NOT enough with just an atomic test-and-set here # since we need to wait during the time a close initiated # from another thread is in progress, before exiting. self.closelock.acquire() try: if not self.isclosed: self.isclosed = 1 self.disconnect() finally: self.closelock.release() while hasattr(self, 'th') and self.th.is_alive(): time.sleep(0.5) def connect(self): self.socket = socket.socket(self.address_family, self.socket_type) while not self.isclosed: try: self.socket.connect(self.server_address) except SystemExit: raise except socket.error: if self.isclosed: raise time.sleep(2) else: break else: return self.stdout = io.TextIOWrapper( self.socket.makefile('wb', buffering=0), encoding='utf-8', write_through=True) self.stdin = NotiInput(io.TextIOWrapper( InterruptableSocket(self.socket.makefile('rb', buffering=0)), encoding='utf-8', write_through=True), self.stdout) self.stderr = sys.stderr self.start_ki_thread() cmd.Cmd.__init__(self, stdin=self.stdin, stdout=self.stdout) def start_ki_thread(self): # Start a thread that can generates keyboard interrupr # Inserts a spy thread between old stdin and a new stdin queue = QueueWithReadline() ostdin = self.stdin self.stdin = NotiInput(input=queue, output=ostdin.output) socket = self.socket def run(): try: while socket is self.socket: line = ostdin.input.readline() if not line: break if line == KEYBOARDINTERRUPT: if socket is self.socket: heapyc.set_async_exc(self.target.annex_thread, KeyboardInterrupt) else: queue.put(line) finally: if socket is self.socket: heapyc.set_async_exc(self.target.annex_thread, SocketClosed) self.th = threading.Thread(target=run, args=()) self.th._hiding_tag_ = self.intlocals['hp']._hiding_tag_ self.th.start() def disconnect(self): sock = self.socket if sock is None: return self.socket = None try: sock.send(DONE) except Exception: pass try: sock.shutdown(socket.SHUT_RDWR) except Exception: pass try: sock.close() except Exception: pass sys.last_traceback = None def do_close(self, arg): self.asynch_close() return 1 def help_close(self): print("""close ----- Close and disable this remote connection completely. It can then not be reopened other than by some command from within the target process. Normally you shouldn't need to use this command, because you can return to the Monitor via other commands (<Ctrl-C> or .) keeping the connection open. But it might be useful when you want to get rid of the remote control interpreter and thread, if it uses too much memory or disturbs the target process in some other way.""", file=self.stdout) do_h = cmd.Cmd.do_help def help_h(self): print("""h(elp) ----- Without argument, print the list of available commands. With a command name as argument, print help about that command.""", file=self.stdout) help_help = help_h def do_int(self, arg): # XXX We should really stop other tasks while we use changed stdio files # but that seems to be hard to do # so this is ok for some practical purposes. # --- new note May 8 2005: # --- and doesn't matter since we are in a different interpreter - # --- so there is no XXX issue ? ostdin = sys.stdin ostdout = sys.stdout ostderr = sys.stderr try: sys.stdin = self.stdin sys.stdout = self.stdout sys.stderr = self.stdout con = Console(stdin=sys.stdin, stdout=sys.stdout, locals=self.intlocals) con.interact( "Remote interactive console. To return to Annex, type %r." % con.EOF_key_sequence) finally: sys.stdin = ostdin sys.stdout = ostdout sys.stderr = ostderr def help_int(self): print("""int ----- Interactive console. Bring up a Python console in the Remote Control interpreter. This console will initially have access to a heapy constructor, named hpy, and a ready-made instance, named hp, and the target (see also the reset command). Other things may be imported as needed. After returning to the Annex (by q) or to the Monitor (by . or <Ctrl-C>), the data in the interactive console will remain there - and will be available till the next time the console is entered. But the data may be cleared and reset to the initial state - a new heapy instance will be created - by the 'reset' command of Annex. It should be noted that the interpreter thread under investigation is executing in parallell with the remote control interpreter. So there may be some problems to do with that if both are executing at the same time. This has to be dealt with for each case specifically.""", file=self.stdout) _bname = 'a1e55f5dc4c9f708311e9f97b8098cd3' def do_isolatest(self, arg): hp = self.intlocals['hp'] a = [] self._a = a b = [] self.intlocals[self._bname] = b # to make __builtins__ exist if it did not already eval('0', self.intlocals) testobjects = [a, b, self.intlocals['__builtins__'], self.intlocals, hp] h = hp.heap() if hp.iso(testobjects) & h: print('Isolation test failed.', file=self.stdout) for i, v in enumerate(testobjects): if hp.iso(v) & h: print( '-- Shortest Path(s) to testobjects[%d] --' % i, file=self.stdout) print(hp.iso(v).shpaths, file=self.stdout) else: print('Isolation test succeeded.', file=self.stdout) del self._a del self.intlocals[self._bname] def help_isolatest(self): print("""isolatest ---------- Isolation test. Test that the target interpreter heap view is isolated from the data in the remote control interpreter. Data introduced here, eg in the interactive console, should not be seen in the heap as reported by hp.heap() etc. This is achieved by setting hp to not follow the calling interpreter root. However, this isolation may become broken. This test is intended to diagnose this problem. The test checks that none of a number of test objects is visible in the target heap view. If the test failed, it will show the shortest path(s) to each of the test objects that was visible.""", file=self.stdout) def do_q(self, arg): print('To return to Monitor, type <Ctrl-C> or .', file=self.stdout) print("To close this connection ('permanently'), type close", file=self.stdout) def help_q(self): print("""q ----- Quit. This doesn't currently do anything except printing a message. (I thought it would be too confusing to have a q (quit) command from the Annex, when there was a similarly named command in the Monitor.)""", file=self.stdout) def do_reset(self, arg): self.intlocals.clear() self.intlocals.update( {'hpy': self.hpy, 'hp': self.hpy(), 'target': self.target }) # Set shorthand h, it is so commonly used # and the instance name now used in README example etc self.intlocals['h'] = self.intlocals['hp'] def help_reset(self): print("""reset ----- Reset things to an initial state. This resets the state of the interactive console data only, for now. It is reinitialized to contain the following: hpy --- from guppy import hpy hp --- hp = hpy() target --- a reference to some data in the target interpreter h --- h = hp; h is a shorthand for hp (The hpy function is modified here from the normal one so it sets some options to make it be concerned with the target interpreter heap under investigation rather than the current one.) """, file=self.stdout) def do_stat(self, arg): print("Target overview", file=self.stdout) print("------------------------------------", file=self.stdout) print("target.sys.executable = %s" % self.target.sys.executable, file=self.stdout) print("target.sys.argv = %s" % self.target.sys.argv, file=self.stdout) print("target.wd = %s" % self.target.wd, file=self.stdout) print("target.pid = %d" % self.target.pid, file=self.stdout) print("------------------------------------", file=self.stdout) def help_stat(self): print("""stat ----- Print an overview status table, with data from the target interpreter. In the table, sys.executable and sys.argv means the current values of those attributes in the sys module of the target interpreter. The row labeled target.wd is the working directory of the target interpreter, at the time the Remote Control interpreter was started (the actual working directory may have changed since that time). The row labeled target.pid is the process id of the target interpreter. """, file=self.stdout) def hpy(self, args, kwds): from guppy import hpy hp = hpy(args, **kwds) hp.View.is_hiding_calling_interpreter = 1 hp.View.target = self.target self.target._hiding_tag_ = hp._hiding_tag_ self.target.close._hiding_tag_ = hp._hiding_tag_ hp.reprefix = 'hp.' return hp def run(self): try: while not self.isclosed: self.connect() if not self.isclosed: self.do_stat('') while 1: try: self.cmdloop() except SocketClosed: break except Exception: try: traceback.print_exc(file=self.stdout) except Exception: traceback.print_exc(file=sys.stdout) break continue self.disconnect() finally: # Make sure the thread/interpreter can't terminate # without the annex being closed, # and that we WAIT if someone else is being closing us. self.asynch_close() def on(): # Start a remote monitoring enabling thread, # unless I am that thread myself. global annex_thread, target if annex_thread is not None: return if getattr(sys, '_is_guppy_heapy_remote_interpreter_', 0): return start_annex = """\ # Set a flag to stop recursion when importing site # in case sitecustomize tries to do Remote.on() import sys sys._is_guppy_heapy_remote_interpreter_ = 1 import site from guppy.heapy import Remote Remote.Annex(target).run() """ target = Target.Target() annex_thread = heapyc.interpreter(start_annex, {'target': target}) target.annex_thread = annex_thread def off(): global annex_thread, target if annex_thread is None: return for i in range(10): try: close = target.close except AttributeError: # It may not have been initiated yet. # wait and repeat time.sleep(0.05) else: close() break else: raise heapyc.set_async_exc(annex_thread, SystemExit) while True: if not hasattr(heapyc.RootState, 't%d_async_exc' % annex_thread): break else: time.sleep(0.05) annex_thread = target = None annex_thread = None target = None atexit.register(off)	15.31 KB	2026-01-20 12:58
📄 RemoteConstants.py # Constants used in communication between RemoteAccess and Monitor READLINE = 'READLINE\n' KEYBOARDINTERRUPT = 'KEYBOARDINTERRUPT\n' DONE = 'DONE\n' LOCALHOST = '127.0.0.1' #HEAPYPORT = 8834 HEAPYPORT = 3546	209 B	2026-01-20 12:58
📄 Spec.py """ Contains some experimental set constructions. In the current state, not to be used by the faint-hearted. It is likely due for some major refactoring and has probably many bugs, it was a long time since I run the tests. You don't get any other documentation than this right now. """ DEBUG = 1 def briefstr(x): try: return getattr(x, 'brief') except AttributeError: if isinstance(x, tuple): return '(%s)' % (','.join([briefstr(xi) for xi in x])) return str(x) class SpecFamily: def __init__(self, unisetmod, specmod): self.specmod = specmod self.defrefining(unisetmod.Anything) self.disjoints -= [self] def __call__(self, arg): return self.Set(self, arg) def c_and(self, a, b): if isinstance(b, SpecFamily): return self.mod.fam_And._cons((a, b)) else: return b.fam._and_ATOM(b, a) def _and_ID(self, a, b): env = self.specmod._static_test_env res = self.mod.mutnodeset() for bi in b.nodes: try: env.test_contains(a, bi, 'select contains') except Exception: # TestError pass else: res.add(bi) return self.mod.fam_Identity._cons(self.mod.immnodeset(res)) def c_contains(self, a, b): env = self.specmod._static_test_env try: return env.test_contains(a, b, 'Spec contains') except TestError: return False def c_getlimstr(self, a, max_len): x = a.brief if len(x) > max_len: x = x[:max_len-3]+'...' return x def c_get_brief(self, a): return '<%s(%s)>' % (self.__class__.__name__, briefstr(a.arg)) class ArgNamesFamily(SpecFamily): def __call__(self, args): return self.Set(self, args) def getargnames(self, code): inspect = self.specmod._root.inspect (args, varargs, varkw) = inspect.getargs(code) if varargs is not None: args.append('%s' % varargs) if varkw is not None: args.append('*%s' % varkw) return tuple(args) def func_argnames(self, f, args): try: code = f.__code__ return self.getargnames(code) == args except AttributeError: return False def meth_argnames(self, m, args): try: f = m.__func__ code = f.__code__ return self.getargnames(code)[1:] == args except AttributeError: return False def c_contains(self, a, x): def func_argnames(f): return self.func_argnames(f, a.arg) def meth_argnames(m): return self.meth_argnames(m, a.arg) types = self.mod._root.types return (func_argnames(x) or meth_argnames(x) or (isinstance(x, type) and (hasattr(x, '__init__') and meth_argnames(x.__init__))) or (isinstance(x, type) and (hasattr(x, '__init__') and meth_argnames(x.__init__))) or (hasattr(x, '__call__') and meth_argnames(x.__call__)) ) class AttributeFamily(SpecFamily): def __call__(self, name, type=None): if type is None: type = self.specmod.any else: if not isinstance(type, self.mod.UniSet): type = self.c_from(type) return self.specotup((name, type)) def c_test_contains(self, a, b, env): name, type = a.arg x = env.gengetattr(b, name) return type.test_contains(x, env) def c_get_brieflimstr(self, a): x = '<AttributeFamily(%r%%s>' % (a.arg[0],) if a.arg[1] is not None: x = x % (','+a.arg[1].brief) else: x = x % '' return x class AdaptupleFamily(SpecFamily): def __init__(self, a, *k): SpecFamily.__init__(self, a, *k) self.add_export('new', lambda x: x.arg[0]) def __call__(self, func, type): func, doc = self.specmod._exodoc(func) type = self.specmod.setcast(type) return self.specoargtup((func, type), (doc, type)) def c_test_contains(self, a, b, env): func, type = a.arg if isinstance(b, tuple): try: x = func(b) except Exception: return env.failed_exc_info('calling func failed') else: x = b return type.test_contains(x, env) class CartesianProductFamily(SpecFamily): def __call__(self, types): return self.Set(self, types) def c_domain(self, a): types = a.arg if len(types) == 2: return types[0] raise TypeError('Domain is defined on binary relations only') def c_get_examples(self, a, env): # We have to check length before calling iterpermute - # to give a reasonable error message examples are missing from some set. exs = [] for i, ai in enumerate(a.arg): ex = list(env.get_examples(ai)) if not ex: # ??? if not env.failed_coverage('cartesian product', ai, None, 'the argument #%d' % i): return [] exs.append(ex) return self.mod._root.guppy.etc.iterpermute(exs) def c_len(self, a): l = 1 for ai in a.arg: l = l * len(ai.arg) return l def c_test_contains(self, a, b, env): types = a.arg bs = tuple(b) if len(types) != len(bs): env.failed('cprod of length %d: argument has length %d' % (len(types), len(bs))) else: for t, b in zip(types, bs): if not t.test_contains(b, env): return False return True class SequenceFamily(SpecFamily): def __call__(self, type): return self.specoarg(type) def c_test_contains(self, a, b, env): for x in b: if not a.arg.test_contains(x, env): return False return True def c_get_examples(self, a, env): for i in range(env.max_sequence_examples_length): for x in env.get_examples(self.specmod.cprod([a.arg]i)): yield x class MappingFamily(SpecFamily): def __init__(self, a, k): SpecFamily.__init__(self, a, *k) self.add_export('arrow', lambda x: lambda f: self.c_arrow(x, f)) def c_arrow(self, a, f): tf, ts, ret = a.arg return Arrow(ts, ret, f) def __call__(self, args): ts = [] as_ = [] ret = None i = 0 setcast = self.specmod.setcast while i < len(args): ai = args[i] if isinstance(ai, str): if ai == '->': i += 1 if not i == len(args)-1: raise SyntaxError( "The '->' specifier must be next to last in the argument list") ret = setcast(args[i]) elif ai.endswith('='): i += 1 t = setcast(args[i]) as_.append('%s=%args[%d]' % (ai[:-1], len(ts))) ts.append(t) elif ai == '': i += 1 t = setcast(args[i]) as_.append('args[%d]' % len(ts)) ts.append(self.specmod.sequence(t)) else: raise SyntaxError("Invalid argument specifier: %r" % ai) else: as_.append('args[%d]' % len(ts)) ts.append(setcast(ai)) i += 1 fn = 'lambda f: lambda args: f('+','.join(as_)+')' f = eval(fn) ts = self.specmod.cprod(ts) if ret is None: ret = self.specmod.Anything return self.Set(self, (f, ts, ret)) def c_test_contains(self, a, func, env): f, ts, ret = a.arg f = f(func) def g(env, args): try: r = f(args) except Exception: # TypeError, ValueError, AttributeError ... - what not raise #env.failed('Call exception') else: if ret is not None: return env.test_contains(ret, r, "Mapping Return Type") else: return True return env.forall(ts, g) def c_get_examples(self, a, env): f, ts, ret = a.arg return [lambda args, *kwds: x for x in env.get_examples(ret)] class PredicateFamily(SpecFamily): def __call__(self, arg, doc): return self.Set(self, (arg, doc)) def c_test_contains(self, a, b, env): pred, doc = a.arg if not pred(env, b): return env.failed('pred: doc = %r; failed for element == %s' % (doc, env.name(b))) return True class PowersetFamily(SpecFamily): def __init__(self, args): SpecFamily.__init__(self, args) self.add_export('union', lambda x: x.arg) def __call__(self, set): return self.specoarg(set) def c_get_examples(self, a, env): x = [self.specmod.Nothing, a.arg] try: y = env.get_examples(a.arg) except Exception: # xxx complain? We can always generate 2 examples.. return x # xxx should we make all permutations?.. return x def c_test_contains(self, a, b, env): if not b in self.specmod.set: env.failed('powerset.test_contains: not a set: %s' % self.specmod.iso(b)) set = a.arg return env.forall(b, lambda env, x: env.test_contains(set, x, 'powerset'), 'powerset') class DocFamily(SpecFamily): def __call__(self, doc, type=None): if type is None: type = self.specmod.UniSet.NotNothing else: if not type in self.specmod.set: type = self.specmod.UniSet.convert(type) return self.Set(self, (doc, type)) def c_test_contains(self, a, b, env): doc, type = a.arg return type.test_contains(b, env) class RelOpFamily(SpecFamily): def __init__(self, a, *k): SpecFamily.__init__(self, a, *k) self.add_export('domain', lambda x: x.arg[0]) self.add_export('range', lambda x: x.arg[2]) # The memo dict keeps relops with the same domain, op, and range. # Primarily introduced to make equality work with default mechanism, # since different compiled func's compared differently even with # the same source. self.memo = {} def __call__(self, domain, op, range=None): domain = self.specmod.setcast(domain) if range is None: range = domain else: range = self.specmod.setcast(range) x = self.memo.get((domain, op, range)) if x is None: if op in ('<', '<=', '==', '!=', '>', '>=', 'in', 'not in', 'is', 'is not'): func = eval('lambda x,y: x %s y' % op) func.name = op else: func = op func.name = func.__name__ x = self.Set(self, (domain, func, range)) self.memo[(domain, op, range)] = x return x def c_get_examples(self, a, env): # We have to check length before calling iterpermute - # to give a reasonable error message examples are missing from some set. dom = list(env.get_examples(a.domain)) if not dom: failed_coverage('relation', a.domain, None, 'domain') return [] ran = list(env.get_examples(a.range)) if not ran: failed_coverage('relation', a.range, None, 'range') return [] exs = [] for ex in self.specmod._root.guppy.etc.iterpermute(dom, ran): if env.contains(a, ex): exs.append(ex) return exs def c_test_contains(self, a, b, env): d, op, r = a.arg if not op(b): return env.failed() return True class EqualsFamily(SpecFamily): def __call__(self, args): if not args: return self.specmod.Nothing return self.specotup(args) def c_test_contains(self, a, b, env): if b in a.arg: return True return env.failed('equals') def c_get_examples(self, a, env): return a.arg class ExampleFamily(SpecFamily): def __call__(self, set, examples): return self.Set(self, (set, examples)) def c_test_contains(self, a, b, env): set, examples = a.arg return set.test_contains(b, env) def c_get_examples(self, a, env): set, examples = a.arg # for e in examples: env.test_contains(set, e, 'ExampleFamily.c_get_examples') return examples class SynonymsFamily(SpecFamily): def __call__(self, names): return self.Set(self, names) def c_test_contains(self, a, b, env): names = a.arg ms = self.specmod.UniSet.mutnodeset() for name in names: x = env.getattr(b, name) ms.add(x) if not len(ms): env.failed('Synonyms: no such names: %r' % names) if len(ms) > 1: env.failed('Synonyms: %d different nodes for names: %r' % (len(ms), names)) return True class InstanceFamily(SpecFamily): def c_test_contains(self, a, b, env): if not isinstance(b, a.arg): env.failed('InstanceFamily: %s is not an instance of %s' % ( self.specmod.iso(b), a.arg)) return True def c_get_examples(self, a, env): return env.get_examples(self.specmod.setcast(a.arg)) def _and_ID(self, a, b): return self.mod.fam_Identity([bi for bi in b.nodes if isinstance(bi, a.arg)]) class ExpressionPredicateFamily(SpecFamily): def __call__(self, names, expression): func = None return self.Set(self, (names, expression, func)) def c_test_contains(self, a, b, env): names, expression, func = a.arg func = eval('lambda %s:%s' % (','.join(names), expression)) d = {} for name in names: x = env.getattr(b, name) d[name] = x x = func(*d) if not x: env.failed('False expression: %s' % expression) return True class ExpressionSetFamily(SpecFamily): def __call__(self, expression, names): func = None return self.Set(self, (names, expression, func)) def c_test_contains(self, a, b, env): names, expression, func = a.arg func = self.specmod.eval('lambda %s:(%s)' % ( ','.join(('LE',)+tuple(names)), expression)) d = {'LE': env.LE} for name in names: x = env.getattr(b, name) d[name] = x x = func(*d) return env.test_contains(x, b, 'expset(%s, %s)' % (expression, ','.join(names))) class MatchesFamily(SpecFamily): def __init__(self, a, *k): SpecFamily.__init__(self, a, *k) self.sre = self.specmod._root.sre def __call__(self, regexp): return self.specoargtup(self.sre.compile(regexp), (regexp,)) def c_test_contains(self, a, b, env): regexpobj = a.arg m = self.sre.match(regexpobj, b) if m is None: return env.failed('Did not match') return True class RecurSelfFamily(SpecFamily): def __init__(self, a, *k): SpecFamily.__init__(self, a, *k) class RecurSpec(self.Set): __slots__ = 'func', 'recursion_level', 'recursion_limit' self.RecurSpec = RecurSpec def __call__(self, expr, recursion_limit=10): s = self.RecurSpec(self, expr) s.recursion_limit = recursion_limit s.recursion_level = 0 return s def c_test_contains(self, a, b, env): try: func = a.func except AttributeError: expr = a.arg func = a.func = env.eval('lambda self:%s' % expr) s = func(self.specmod.Nothing) try: tf = env.test_contains(s, b, 'recur with Nothing, ok to fail') if not tf: raise TestError except Exception: # TestError: eg for match, we got a TypeError.. s = func(a) rl = a.recursion_level try: if rl >= a.recursion_limit: return env.failed('recurself: recursion_level = %s' % a.recursion_limit) else: a.recursion_level = rl + 1 tf = env.test_contains(s, b, 'recur') finally: a.recursion_level = rl return tf class Dummy: pass class TupleformFamily(SpecFamily): def __call__(self, form, set): return self.specotup((form, set)) def c_test_contains(self, a, b, env): form, set = a.arg bt = tuple(b) if len(bt) != len(form): return env.failed('tupleform: wrong length: got %d expected %d' % (len(bt), len(form))) ob = Dummy() for name, val in zip(form, bt): setattr(ob, name, val) return env.test_contains(set, ob, 'tupleform') class Arrow: def __init__(self, category, source, target): self.category = category self.source = source self.target = target def of(self, other): # compose self <-- other # (Standard composition order) other = self.category.validate(other) return self.category.compose(self, other) def to(self, other): # compose self --> other # (Nonstandard composition order; sometimes seems more natural) other = self.category.validate(other) return self.category.compose(other, self) class IdentityArrow(Arrow): def __init__(self, category, object): Arrow.__init__(self, category, object, object) def __call__(self, x): return x class FunctionArrow(Arrow): def __init__(self, category, source, target, function): Arrow.__init__(self, category, source, target) self.__call__ = function class RepresentationCategory: _derive_origin_ = None _origin_ = None def __init__(self, mod, spec): fam = mod.family(RepresentationObjectFamily) fam.init2(self, spec) self._fam = fam def __eq__(self, other): return self is other def __hash__(self): return hash(id(self)) def __getattr__(self, name): r = self._fam.getobject(name) self.__dict__[name] = r return r class RepresentationObjectFamily(SpecFamily): def init2(self, cat, spec): self.cat = cat self.objects = {} self.specs = {} self.arrows = {} self.add_export('fromuniversal', self.fromuniversal) Set = self.Set class RepresentationObject(Set): __slots__ = 'to', 'from' self.Set = RepresentationObject class RepresentationCategorySpec(spec): def __init__(self, fam): self._fam = fam self._cat = fam.cat def __getattr__(self, name): if hasattr(self.__class__, '_get_%s' % name): r = getattr(self, '_get_%s' % name)(self._fam.specmod) self.__dict__[name] = r return r raise AttributeError(name) self.spec = RepresentationCategorySpec(self) def getarrow(self, dom, cod): dc = (dom, cod) if dc in self.arrows: return self.arrows[dc] raise SpecError def getobject(self, name): if name in self.objects: return self.objects[name] normname = self.normoname(name) if normname in self.objects: self.objects[name] = self.objects[normname] return self.objects[normname] o = self(normname) self.objects[normname] = self.objects[name] = o return o raise SpecError('No such object: %r' % name) def getspec(self, obj): name = obj.arg if name in self.specs: return self.specs[name] gs = getattr(self.spec, '_get_spec_%s' % name, None) if gs is not None: sp = gs(self.specmod) self.specs[name] = sp return sp raise SpecError('getspec: No spec of %r' % name) def fromuniversal(self, target): # Find a most general arrow into 'target' # 1. Find all predefined arrows to target # 2. Make a category sum of the set of sources S of all such arrows # 3. Make a specification-set P for this sum, which is that: # a. The element should be isomorphic to a tuple (O, A) where # b. O, the tag, should be an object in S # c. A, the value, should be an element in O # Return an arrow taking this object to target. # # Arrows thus created are memoized. name = target.arg arrowname = '%s.fromuniversal' % name if arrowname in self.arrows: return self.arrows[arrowname] S = {} S[name] = IdentityArrow(self.cat, target) for an in dir(self.spec): if not (an.startswith('map_') and '_to_' in an): continue s, t = an.split('_to_') s = s[4:] if t == name: f = getattr(self.spec, an) S[s] = FunctionArrow(self.cat, getattr(self.cat, s), target, lambda x: f(self.specmod, x)) def p(env, e): try: O, A = e except Exception: return env.failed('Not a sequence with length 2') fam = getattr(O, 'fam', None) if fam is not self: return env.failed('Tag is not an object of this family') name_ = getattr(O, 'arg', None) if name_ not in S: return env.failed('Object is not a source of this target') return env.test_contains(O, A, 'Value is not an element of this object') uniname = '%s.universal' % name P = self.specmod.predicate(p, 'Specification-set for %r' % uniname) self.specs[uniname] = P source = self(uniname) class AlphaSum(Arrow): def __init__(self, category, source, target, S): Arrow.__init__(self, category, source, target) self._S = S def __getitem__(self, x): # Don't know what to call this unique arrow return self._S[self.source.fam.normoname(x)] def __call__(self, xxx_todo_changeme): (O, E) = xxx_todo_changeme return self[O.arg](E) arrow = AlphaSum(self.cat, source, target, S) self.arrows[arrowname] = arrow return arrow def normoname(self, on): isos = getattr(self.spec, '_isos_', None) if isos is not None: for l in self.spec._isos_: nn = None for n in l: if n.isdigit(): nn = n if n == on: if nn is not None: return nn raise SpecError( 'No numeric object name corresponding to %r' % on) return on def __call__(self, name): r = self.specoarg(name) class To: __slots__ = 'source', def __init__(self, source): self.source = source def __call__(self, target): return self.source.fam.getarrow(self.source, target) def __getattr__(self, name): source = self.source fam = source.fam target = fam.getobject(name) return fam.getarrow(source, target) r.to = To(r) return r def c_test_contains(self, a, b, env): set = self.getspec(a) return env.test_contains(set, b, 'RepresentationObjectFamily: not in object specification') def c_get_examples(self, a, env): set = self.getspec(a) return env.get_examples(set) class AbstractSetFamily(SpecFamily): def __init__(self, a, *k): SpecFamily.__init__(self, a, *k) class AbstractSet(self.Set): __slots__ = '_memo', def __init__(self, fam, arg): self.fam = fam self.arg = arg self._origin_ = None self._memo = {} self.Set = AbstractSet def __call__(self, arrow, set): r = self.specotup((arrow, set)) r._memo = {} return r def c_and(self, a, b): if b.fam is self: aa, sa = a.arg ab, sb = b.arg if aa is ab: return self(aa, sa & sb) return b.fam._rand_ATOM(b, a) def c_getattr2(self, a, b): if b in a._memo: return a._memo[b] arrow, set = a.arg pararrow = arrow[b] srcset = pararrow.source def p(env, x): t = env.test_contains( srcset, x, 'AbstractSet: not in arrow.source') if t: e = pararrow(x) t = env.test_contains( set, e, 'AbstractSet: not in argument set') return t return env.contains(set, y) s = self.specmod.predicate(p, 'Abstract set attribute: %r' % b) # ... a._memo[b] = s return s def c_test_contains(self, a, b, env): arrow, set = a.arg t = env.test_contains( arrow.source, b, 'AbstractSet: not in arrow.source') if t: e = arrow(b) t = env.test_contains(set, e, 'AbstractSet: not in argument set') return t class ElemFamily(SpecFamily): def __call__(self, func): return self.specoarg(func) def c_test_contains(self, a, b, env): func = a.arg s = func(b) return env.test_contains(s, b, 'ElemFamily') class IntersectionFamily(SpecFamily): def __call__(self, domain, function): return self.specotup((domain, function)) def c_test_contains(self, a, b, env): domain, function = a.arg return env.forall(domain, lambda env, x: env.test_contains(function(x), b, 'Intersection')) class SpecError(Exception): pass class TestError(Exception): pass class CoverageError(Exception): pass class LocalEnv: _derive_origin_ = 'ADD' def __init__(self, mod, spec, nodoc=1): self._mod = mod self._spec = spec self._origin_ = None self.nodoc = nodoc def __getattr__(self, attribute_name): mod = self._mod f = getattr(self._spec, attribute_name) d = self._mod._load_names( mod._root.guppy.etc.Code.co_findloadednames(f.__code__)) nf = mod._root.types.FunctionType( f.__code__, d, f.__name__, f.__defaults__, f.__closure__) r = nf(()) self.__dict__[attribute_name] = r return r class TestEnv: _derive_origin_ = 'ADD' iscomplete = False issilent = False # ie. (), cprod(x) cprod(x, y) are yielded by default max_sequence_examples_length = 2 TestError = TestError def __init__(self, mod, Spec): self.mod = mod self.messages = [] self.examples = {} if Spec is not None: self.spec = spec = Spec() try: lex = spec.LocalEnvExpr except AttributeError: lex = '' LE = LocalEnv(mod, lex) LE._OBJ_ = mod self.LE = LE self.topspec = self.eval(spec.GlueTypeExpr) def eval(self, expr): mod = self.mod types = mod._root.types if isinstance(expr, (str,)): func = self.mod.eval('lambda LE:(\n%s\n)' % expr) return func(self.LE) ls = [] selfset = None names = list(expr.__dict__.keys()) names.sort() for name in names: f = getattr(expr, name) try: co = f.__code__ except AttributeError: continue if co.co_varnames[:co.co_argcount] == ('IN',): d = mod._load_names( mod._root.guppy.etc.Code.co_findloadednames(co)) #d = mod._load_names() nf = mod._root.types.FunctionType( f.__code__, d, f.__name__, f.__defaults__, f.__closure__) s = nf(()) if name == '_SELF_': selfset = s else: ls.append(mod.attr(name, s)) else: raise SpecError('TestEnv.eval: invalid argument mode') # Constructing an AND in one sweep = faster # We assume they are not disjoint - which # would be determined by testing that we are going to do # (We know they are all attr's of different names here) # Except that selfset may perhaps be disjoint; but why care here # if selfset is not None: ls.append(selfset) # Alternatively: r = r & selfset afterwards, # but could be unnecessarily slow r = mod.UniSet.fam_And._cons(ls) return r def get_examples(self, collection): try: it = iter(collection) except TypeError: try: ex = self.examples[collection] except KeyError: if isinstance(collection, self.mod.UniSet.UniSet): ex = collection.get_examples(self) else: ex = list(collection) it = iter(ex) return it def getattr(self, obj, name): if '.' in name: x = obj for subname in name.split('.'): try: x = getattr(x, subname) except Exception: return self.failed('getattr: %s has no attribute %r' % (self.name(obj), name) + ',\nbecause %s has no attribute %r' % (self.name(x), subname)) else: try: x = getattr(obj, name) except Exception: if DEBUG: raise return self.failed('attr: %s has no attribute %r' % (self.name(obj), name)) return x def gengetattr(self, obj, name_or_tuple): if isinstance(name_or_tuple, str): return self.getattr(obj, name_or_tuple) elif isinstance(name_or_tuple, tuple): if len(name_or_tuple) == 2 and name_or_tuple[0] is self.mod.quote: return name_or_tuple[1] else: return tuple([self.gengetattr(obj, nt) for nt in name_or_tuple]) else: raise TypeError('gengetattr: I am picky, required string or tuple') def log(self, message): self.messages.append(message) def name(self, obj): if isinstance(obj, self.mod.UniSet.UniSet): return str(obj) else: return '%s' % self.mod.iso(obj) def name_coll(self, collection): return '%s' % collection def test(self, obj): self.get_obj_examples(obj) try: self.test_contains(self.topspec, obj, 'Top spec') except Exception: tvt = self.mod._root.sys.exc_info() self.dump_failure(tvt) def get_obj_examples(self, obj): ex = self.spec.GetExamples(self, obj) for e in ex: vs = e[1:] e = e[0] s = self.examples.setdefault(e, []) for v in vs: s.append(v) self.test_contains(e, v, 'testing example of set') def dump_failure(self, xxx_todo_changeme3, noraise=0): (type, value, traceback) = xxx_todo_changeme3 list = [] tb = traceback while tb is not None: f = tb.tb_frame if f.f_code is self.test_contains.__func__.__code__: list.append(f) tb = tb.tb_next for f in list: lo = f.f_locals print('a = %r' % (lo['a'],)) print('b = %r' % (lo['b'],)) print('message = ', lo['message']) print('-----') if noraise: self.mod._root.traceback.print_exception(type, value, traceback) else: raise def contains(self, a, b): try: x = self.test_contains(a, b, 'contains') except CoverageError: raise except Exception: return False return x def test_contains(self, a, b, message): return a.test_contains(b, self) def test_contains_not(self, a, b, message): try: a.test_contains(b, self) except CoverageError: raise except Exception: # TestError: # well we axcept anything.. ok? return True else: return self.failed('test_contains_not, from: %s' % message) def failed(self, message=''): if not self.issilent: self.log('Failed:' + message) raise TestError(message) return False def failed_coverage(self, forwhat, collection, func, message): if collection is self.mod.Nothing: return True raise CoverageError('%s: no examples for collection = %s, message: %s' % ( forwhat, collection, message)) def failed_exc_info(self, message): exc_info = self.mod._root.sys.exc_info() type, value, traceback = exc_info if not self.issilent: self.log('Failed:' + message) raise type(value) return False def forall(self, collection, func, message=''): ex = self.get_examples(collection) n = 0 for e in ex: if not func(self, e): return self.failed('forall: e = %s, from: %s' % (self.name(e), message)) n += 1 if not n: try: a = len(collection) if a > 0: raise CoverageError # Otherwise ok, it was really an Nothing collection. except Exception: self.failed_coverage('forall', collection, func, message) return True def forall_pairs(self, collection, func, message=''): as_ = self.get_examples(collection) n = 0 for a in as_: for b in self.get_examples(collection): if not func(self, a, b): self.failed('forall_pairs: a = %s, b = %s, from: %s' % ( self.name(a), self.name(b), message)) n += 1 if not n: self.failed_coverage('forall_pairs', collection, func, message) return True def forall_triples(self, collection, func, message=''): as_ = self.get_examples(collection) n = 0 for a in as_: for b in self.get_examples(collection): for c in self.get_examples(collection): if not func(self, a, b, c): self.failed('forall_triples: a = %s, b = %s, c=%s, from: %s' % ( self.name(a), self.name(b), self.name(c), message)) n += 1 if not n: self.failed_coverage('forall_triples', collection, func, message) return True def forsome(self, collection, func, message=''): failures = [] for i, x in enumerate(collection): try: b = func(x) except Exception: # TestError: failures.append((i, self.mod._root.sys.exc_info())) continue if b: return True for (i, tvt) in failures: print('forsome: exception at collection[%d]:' % i) self.dump_failure(tvt, noraise=1) self.failed(message) class _GLUECLAMP_: _chgable_ = '_loaded', _nowrap_ = ('_origin_', 'Doc', 'family', 'eval', 'setcast', 'compile', 'wrap_source_string', '_load_names', 'iso') _preload_ = '_hiding_tag_', # 'imports' _imports_ = ( '_parent:Use', '_parent.Use:iso', '_parent.Use:Nothing', ) def _get_UniSet(self): return self._parent.UniSet def _get_Doc(self): return self._parent.Doc def _get_View(self): return self._parent.View # def _get__origin_(self): return self.Doc.attribute(self.Doc.root, 'guppy.heapy.Spec') def _wrapattr_(self, obj, name): Doc = self.Doc if name == 'setof': pass try: obj = Doc.wrap(obj, Doc.attribute(self._origin_, name)) except Doc.DocError: __import__('traceback').print_exc() print('no wrap:', name) return obj def _get_abstractset(self): return self.family(AbstractSetFamily) def _get_adaptuple(self): return self.family(AdaptupleFamily) def _get_any(self): return ~self.Nothing def _get_argnames(self): return self.family(ArgNamesFamily) def _get_attr(self): return self.family(AttributeFamily) def attrs(self, names, type=None): x = self.any for n in names: x &= self.attr(n, type) return x def _get_boolean(self): def p(env, x): try: if x: pass except Exception: env.failed("boolean: 'if x' raised an exception") return True return self.predicate(p, 'boolean') def _get_callable(self): return self.predicate(lambda env, x: callable(x), 'callable') def _get_compile(self): token = self._root.token parser = self._root.parser symbol = self._root.symbol def mapchildren_id(node, f): return node def mapchildren_default(node, f): return [node[0]] + [f(n) for n in node[1:]] mapchildren_dispatch = dict( [(value, mapchildren_id) for value in range(token.N_TOKENS)]) mapchildren_dispatch.update(dict([(value, mapchildren_default) for value, name in list(symbol.sym_name.items())])) def mapchildren(node, f): return mapchildren_dispatch[node[0]](node, f) def visitor(C): d = mapchildren_dispatch.copy() for value, name in list(symbol.sym_name.items()): if hasattr(C, name): d[value] = getattr(C, name).__func__ def _visit(node): return d[node[0]](node, _visit) return _visit def recover_source_node(node, l): for n in node[1:]: recover_source_dispatch[n[0]](n, l) def recover_source_token(node, l): if l and l[-1] != '(': l.append(' ') l.append(node[1]) def recover_source_name(node, l): if l and l[-1] not in ('.', '('): l.append(' ') l.append(node[1]) def recover_source_tight_left(node, l): l.append(node[1]) def recover_source_lpar(node, l): if l and not (l[-1][-1:].isalnum() or l[-1] == '('): l.append(' ') l.append(node[1]) recover_source_dispatch = dict([(value, recover_source_node) for value, name in list(symbol.sym_name.items())]) recover_source_dispatch.update( dict([(value, recover_source_token) for value in range(token.N_TOKENS)])) recover_source_dispatch[token.NAME] = recover_source_name for tok in ('RPAR', 'LSQB', 'RSQB', 'COLON', 'COMMA', 'SEMI', 'DOT', 'LBRACE', 'RBRACE'): recover_source_dispatch[getattr( token, tok)] = recover_source_tight_left recover_source_dispatch[token.LPAR] = recover_source_lpar def recover_source(node): l = [] recover_source_dispatch[node[0]](node, l) return ''.join(l) class wrap_lambdef: def test(node, f): # and_test ('or' and_test) \| lambdef if len(node) == 2 and node[1][0] == symbol.lambdef: lsource = recover_source(node[1]) lnode = mapchildren(node[1], f) return ( 292, (293, (294, (295, (297, (298, (299, (300, (301, (302, (303, (304, (305, (1, 'wrap_source_string')), (308, (7, '('), (317, (318, (292, lnode)), (12, ','), (318, (292, (293, (294, (295, (297, (298, (299, (300, (301, (302, (303, (304, (305, (3, '%r' % lsource )))))))))))))))), (8, ')')))))))))))))) return mapchildren(node, f) wrap_lambdef = visitor(wrap_lambdef) def compile_(source, filename, mode, args): if mode != 'spec': return compile(source, filename, mode, args) ast = parser.expr(source) node = parser.ast2tuple(ast, line_info=1) node = mapchildren(node, wrap_lambdef) ast = parser.tuple2ast(node) co = parser.compileast(ast) return co return compile_ def _get_cprod(self): return self.family(CartesianProductFamily) def dictof(self, set=None): return self.UniSet.byclodo.dictof(set) def _get_doc(self): return self.family(DocFamily) def docof(self, set): doc = (set.doc % self._origin_).shortest() do = str(doc) print(do) return do def eval(self, expr, init=None, nodoc=0): if nodoc: mode = 'eval' else: mode = 'spec' co = self.compile(expr, '', mode) d = self._load_names(self._root.guppy.etc.Code.co_findloadednames(co)) if init is not None: d = d.copy() exec(init, d) return eval(co, d) def _get_all_names(self): names = {'_root': 1} for x in _GLUECLAMP_.__dict__: if x.startswith('_get_'): x = x[5:] names[x] = 1 return names def _load_names(self, names=None): if names is None: if '_loaded' not in self.__dict__: for x in self.all_names: getattr(self, x) self._loaded = 1 else: all = self.all_names for name in names: if name in all: getattr(self, name) d = self.__dict__ d['__builtins__'] = self._load_names.__globals__['__builtins__'] return d def _get_eg(self): return self.family(ExampleFamily) def _get_elem(self): return self.family(ElemFamily) def _exodoc(self, expr): if expr in self.LE.string: r = self.eval(expr) return r, self.Doc.anon(expr) elif (expr in self.Type.Function and expr.__code__.co_name == '<lambda>' and expr.__code__.co_filename.startswith('<!SPECEVAL!>')): fn = expr.__code__.co_filename lines = fn.split('\n') lnum = expr.__code__.co_firstlineno inspect = self._root.inspect print(lines[lnum:]) block = inspect.getblock(lines[lnum:]) source = '\n'.join(block) return expr, self.Doc.getdoc(source) else: return expr, self.Doc.getdoc(expr) def _get_expred(self): return self.family(ExpressionPredicateFamily) def _get_expression(self): def p(env, x): try: eval('lambda : %s' % x) except SyntaxError: env.failed('Not a valid expression: %r' % x) return True return self.predicate(p, 'expression') def _get_expset(self): return self.family(ExpressionSetFamily) def _get_equals(self): return self.family(EqualsFamily) def family(self, fam, args, kwds): return self.UniSet.fam_mixin_argatom(fam, self, args, *kwds) def _get__hiding_tag_(self): return self.UniSet._hiding_tag_ def _get_instance(self): return self.family(InstanceFamily) def _get_intersection(self): return self.family(IntersectionFamily) def _get_LE(self): return LocalEnv(self, self._Specification_.LocalEnvExpr) def _get_SPLE(self): return self.LE def _get_mapping(self): return self.family(MappingFamily) def _get_matches(self): return self.family(MatchesFamily) def mkTestEnv(self, Spec): return TestEnv(self, Spec) def newtype(self, name): return self.predicate(lambda e, x: 1, name) # xxx new family? def _get_nothing(self): return self.Use.Nothing def partition(self, set): return self.doc('partition', self.union_equals(set) & self.LE.nonempty & self.set_of_disjoint_sets ) def _get_predicate(self): return self.family(PredicateFamily) def _get_powerset(self): return self.family(PowersetFamily) def _get_Anything(self): return self.UniSet.Anything def _get_quote(self): return [] def _get_recurself(self): return self.family(RecurSelfFamily) def _get_relation(self): # relation is a representation category # We have the following representation objects: # 1. set of pairs with attribute dom, cod # 2. set of pairs with dom is cod # 3. fuop = func \| op, string in ('==',..) # 4. (A, fuop), where A is a set # 5. (A, fuop, B), where A and B are sets # # A final object is 1. class RelationSpec: _isos_ = [ ('1', 'paxb'), ('2', 'paxa'), ('3', 'defiop', 'fuop', ), ('4', 'defipair'), ('5', 'defitriple'), ] def _get_spec_1(self, e): return e.setof(e.cprod(e.Anything, e.Anything)) def _get_spec_2(self, e): return (e.setof(e.cprod(e.Anything, e.Anything))) def _get_spec_3(self, e): return (e.boolean << (e.Anything, e.Anything) \| e.equals('<', '<=', '==', '!=', '>', '>=', 'in', 'not in', 'is', 'is not')) def _get_spec_4(self, e): return e.cprod(e.set, self._cat.fuop) def _get_spec_5(self, e): return e.cprod(e.set, self._cat.fuop, e.set) def _get__relop(self, e): return e.family(RelOpFamily) map_2_to_1 = id def map_3_to_4(self, e, fuop): return (e.Anything, fuop) def map_3_to_2(self, e, fuop): return self._relop(e.Anything, fuop) # redundant def map_4_to_2(self, e, args): return self._relop(args) def map_5_to_1(self, e, args): return self._relop(*args) return self.repcat(RelationSpec) def _get_relop(self): return self.relation.defiop.to.paxa def repcat(self, spec): return RepresentationCategory(self, spec) def _get_sequence(self): return self.family(SequenceFamily) def _get_set(self): return self.instance(self.UniSet.UniSet) def _get_set_of_disjoint_sets(self): def p(env, x): return env.forall_pairs(x, lambda env, a, b: a == b or a.disjoint(b), 'a == b or a.disjoint(b)') return self.predicate(p, 'set of disjoint sets') def setcast(self, arg): if not isinstance(arg, self.UniSet.UniSet): arg = self.UniSet.convert(arg) arg = self.Doc.wrap(arg, self.Doc.callfunc( self.Doc.attribute(self._origin_, 'setcast'), arg)) return arg def _get_setof(self): return self.powerset def _get__static_test_env(self): return self.mkTestEnv(None) def _get_synonyms(self): return self.family(SynonymsFamily) def _get_tupleform(self): return self.family(TupleformFamily) def _get_Type(self): return self.Use.Type def union_equals(self, set): return self.eg(self.attr('union', self.equals(set)), self.powerset(set)) def wrap_source_string(self, func, str): func._origin_ = self.Doc.source(str) return func	48.59 KB	2026-01-20 12:58
📄 Target.py import os import sys class Target: def __init__(self, _hiding_tag_=None): self.wd = os.getcwd() self.pid = os.getpid() self.sys = sys self._hiding_tag_ = _hiding_tag_	205 B	2026-01-20 12:58
📄 UniSet.py from functools import reduce from guppy.etc.Descriptor import property_exp class UniSet(object): __slots__ = '_hiding_tag_', 'fam', '_origin_' _help_url_ = 'heapy_UniSet.html#heapykinds.UniSet' _instahelp_ = '' _doc_nodes = """nodes: ImmNodeSet The actual objects contained in x. These are called nodes because they are treated with equality based on address, and not on the generalized equality that is used by ordinary builtin sets or dicts.""" def __and__(self, other): """ Return the intersection of self and other. """ return self.fam.c_binop('and', self, other) __rand__ = __and__ def __call__(self, args, kwds): return self.fam.c_call(self, args, kwds) def __contains__(self, other): """ Return True if other is a member of self, False otherwise. """ return self.fam.c_contains(self, other) def __eq__(self, other): """ Return True if self contains the same elements as other, False otherwise.""" return self <= other and self >= other def __hash__(self): """ Return an hash based on the kind of the set of self and the addresses of its elements, if any. """ return self.fam.c_hash(self) def __invert__(self): """ Return the complement of self. """ return self.fam.c_unop('invert', self) def __ge__(self, other): """ Return True if self is a superset of (and may be equal to) other, False otherwise. """ if self is other: return True if not isinstance(other, UniSet): other = self.fam.c_uniset(other) return self.fam.c_ge(self, other) def __gt__(self, other): """ Return True if self is a strict (may not be equal to) superset of other. False otherwise. """ return self >= other and not self <= other def __getattr__(self, other): """ Get family-specific attribute. """ return self.fam.mod.View.enter(lambda: self.fam.c_getattr(self, other)) def __le__(self, other): """ Return True if self is a subset of (and may be equal to) other, False otherwise. """ if self is other: return True if not isinstance(other, UniSet): other = self.fam.c_uniset(other) return self.fam.c_le(self, other) def __lshift__(return_spec, argument_spec): """ <<This is about to change, does not work as one may expected. Nov 19 2005. >>> Return a 'mapping' set, which may be used for specification and test purposes. It implements the syntax: return_spec << argument_spec The elements of the set returned are the callable objects that return values in return_spec, when called with arguments according to argument_spec. The return_spec may be any kind of sets that can test for element containment. The argument_spec may be a set or a tuple. If it is a set, it should be able to generate some examples, to allow the mapping to be tested. When argument_spec is a set, the mapping will have a single argument. Any number of arguments may be specified using an argument_spec which is a tuple. The arguments are then specified with sets, that should be able to generate examples. Special features of the mapping such as optional arguments may be specified in the same way as when using the 'mapping' function in the Spec.py module. """ return return_spec.fam.c_lshift(return_spec, argument_spec) def __lt__(self, other): """ Return True if self is a strict (may not be equal to) subset of other, False otherwise. """ return self <= other and not self >= other def __mul__(self, other): """ Return the cartesian product of self and other, which is the set of pairs where the first element is a member of self and the second element is a member of other. NOTE: Unlike what one might expect from the way the cartesian product may be defined mathematically, the operation as implemented here is nonassociative, i.e. abc == (ab)c != a(bc) In the mathematical case, abc would be a set of triples, but here it becomes a set of pairs with the first element in (ab) and the second element in c. To create sets of triples etc. the cprod() factory function in Spec.py could be used directly. """ if not isinstance(other, UniSet): other = self.fam.c_uniset(other) return self.fam.c_mul(self, other) def __ne__(self, other): """ Return True if self does not equal other, False otherwise. See also: __eq__. """ return not self == other def __bool__(self): """ Return True if self contains some element, False otherwise. """ return self.fam.c_nonzero(self) def __or__(self, other): """ Return the union of self and other. """ return self.fam.c_binop('or', self, other) __ror__ = __or__ def __repr__(self): """ Return a string representing self. This is usually the same string as from __str__. """ return self.fam.c_repr(self) def __str__(self): """ Return a string representing self. The string is usually the same as the .brief attribute, but a major exception is the IdentitySet class. """ return self.fam.c_str(self) def __sub__(self, other): """ Return the assymetrical set difference. That is, the set of elements in self, except those that are in others. """ if not isinstance(other, UniSet): other = self.fam.c_uniset(other) return self.fam.c_sub(self, other) def __rsub__(self, other): """ Return the assymetrical set difference. That is, the set of elements in other, except those that are in self. This is like __sub__ except it handles the case when the left argument is not a UniSet (but convertible to a UniSet). """ if not isinstance(other, UniSet): other = self.fam.c_uniset(other) return other.fam.c_sub(other, self) def __xor__(self, other): """ Return the symmetrical set difference. That is, the set of elements that are in one of self or other, but not in both. """ if not isinstance(other, UniSet): other = self.fam.c_uniset(other) return self.fam.c_xor(self, other) __rxor__ = __xor__ brief = property_exp(lambda self: self.fam.c_get_brief(self), doc="""\ A string representation of self, which is brief relative to the representation returned by __str__ and __repr__. (In many cases it is the same - both are then brief - but for IdentitySet objects the brief representation is typically much shorter than the non-brief one.)""" ) def _get_help(self): return self.fam.mod._root.guppy.doc.help_instance(self) doc = property_exp(lambda self: self.fam.mod._root.guppy.etc.Help.dir(self)) def get_ckc(self): # Get low-level classification information, where available. # Returns a tuple (classifier, kind, comparator) return self.fam.c_get_ckc(self) def _derive_origin_(self, doc): """ Return information about the 'origin' of the set. This was intended to be used for specification purposes - is experimental, noncomplete, temporary. """ return self.fam.c_derive_origin(self, doc) def disjoint(self, other): """ Return True if self and other are disjoint sets, False otherwise. This is equivalent to calculating (self & other) == Nothing but may be implemented more efficiently in some cases. """ return self.fam.c_disjoint(self, other) def get_examples(self, env): """ Return an iterable object or an iterator, which provides someexamples of the elements of self. (A minimum of 2 examples should normally be provided, but it may depend on some test configuration options.) This is used for automatic test generation from specifications. The env argument is according to specification of TestEnv in Spec.py, """ return self.fam.c_get_examples(self, env) def get_render(self): """ Return a function that may be used to render the representation of the elements of self. This is mainly intended for internal representation support. The function returned depends on the kind of elements self contains. The rendering function is choosen so that it will be appropriate, and can be used safely, for all objects of that kind. For the most general kind of objects, the rendering function will only return an address representation. For more specialized kinds, the function may provide more information, and can be equivalent to the builtin repr() when the kind is narrow enough that it would work for all elements of that kind without exception. """ return self.fam.c_get_render(self) def test_contains(self, element, env): """ Test if self contains the element object. This is used mainly for internal use for automatic (experimental) testing of specifications. The env argument is according to specification of TestEnv in Spec.py. It provides support for things that depends on the specific test situation, such as a test reporting protocol. If test_contains did find the element to be contained in self, the method will return (usually True). But if the element was not contained in self, the method should call env.failed(message), and return whatever may be returned; though typically env.failed() would raise an exception. """ return self.fam.c_test_contains(self, element, env) biper = property_exp(lambda self: self.fam.c_get_biper(self), doc="""\ A bipartitioning equivalence relation based on x. This may be used to partition or classify sets into two equivalence classes: x.biper(0) == x The set of elements that are in x. x.biper(1) == ~x The set of elements that are not in x. """) dictof = property_exp(lambda self: self.fam.c_get_dictof(self), doc="""dictof: UniSet If x represents a kind of objects with a builtin __dict__ attribute, x.dictof is the kind representing the set of all those dict objects. In effect, x.dictof maps lambda e:getattr(e, '__dict__') for all objects e in x. But it is symbolically evaluated to generate a new symbolic set (a Kind).""") class Kind(UniSet): __slots__ = 'arg', def __init__(self, fam, arg): self.fam = fam self._hiding_tag_ = fam._hiding_tag_ self.arg = arg self._origin_ = None def alt(self, cmp): return self.fam.c_alt(self, cmp) class IdentitySet(UniSet): __slots__ = '_er', '_partition', '_more' _help_url_ = 'heapy_UniSet.html#heapykinds.IdentitySet' def __init__(self, fam): self.fam = fam self._hiding_tag_ = fam._hiding_tag_ self._origin_ = None def __getitem__(self, idx): return self.fam.c_getitem(self, idx) def __len__(self): return self.fam.c_len(self) def __iter__(self): return self.fam.c_iter(self) def __str__(self): """ Return a string representating self. This differs from the .brief attribute in that it is a tabular representation. ... """ return self.fam.c_str(self) def get_rp(self, depth=None, er=None, imdom=0, bf=0, src=None, stopkind=None, nocyc=False, ref=None): """ x.get_rp(depth=None, er=None, imdom=0, bf=0, src=None, stopkind=None, nocyc=False, ref=None) Return an object representing the pattern of references to the objects in X. The returned object is of kind ReferencePattern. Arguments depth The depth to which the pattern will be generated. The default is taken from depth of this module. er The equivalence relation to partition the referrers. The default is Clodo. imdom If true, the immediate dominators will be used instead of the referrers. This will take longer time to calculate, but may be useful to reduce the complexity of the reference pattern. bf If true, the pattern will be printed in breadth-first order instead of depth-first. (Experimental.) src If specified, an alternative reference source instead of the default root. stopkind The referrers of objects of kind stopkind will not be followed. nocyc When True, certain cycles will not be followed. ref See also rp (a shorthand for common cases) """ return self.fam.RefPat.rp(self, depth, er, imdom, bf, src, stopkind, nocyc, ref) def get_shpaths(self, src=None, avoid_nodes=None, avoid_edges=()): """x.get_shpaths(draw:[src, avoid_nodes, avoid_edges]) -> Paths Return an object containing the shortest paths to objects in x. The optional arguments are: src:IdentitySet An alternative source set of objects avoid_nodes:IdentitySet Nodes to avoid avoid_edges:NodeGraph Edges to avoid """ return self.fam.Path.shpaths(self, src, avoid_nodes, avoid_edges) # 'Normal' methods def by(self, er): """ x.by(er) -> A copy of x, but using er for equiv. relation. """ return self.fam.get_by(self, er) def diff(self, other): return self.stat - other.by(self.er).stat def dump(self, args, kwds): """ Dump statistical data to a file Shorthand for .stat.dump """ self.stat.dump(args, *kwds) byclodo = property_exp(lambda self: self.by('Clodo'), doc="""\ A copy of self, but with 'Clodo' as the equivalence relation.""") byidset = property_exp(lambda self: self.by('Idset'), doc="""\ A copy of self, but with 'Idset' as the equivalence relation. Note This is mainly for special purpose internal use. The Id equivalence relation is more efficient when partitioning large sets.""") byid = property_exp(lambda self: self.by('Id'), doc="""\ A copy of self, but with 'Id' as the equivalence relation.""") bymodule = property_exp(lambda self: self.by('Module'), doc="""\ A copy of self, but with 'Module' as the equivalence relation.""") byprod = property_exp(lambda self: self.by('Prod'), doc="""\ A copy of self, but with 'Prod' as the equivalence relation.""") byrcs = property_exp(lambda self: self.by('Rcs'), doc="""\ A copy of self, but with 'Rcs' as the equivalence relation.""") bysize = property_exp(lambda self: self.by('Size'), doc="""\ A copy of self, but with 'Size' as the equivalence relation.""") bytype = property_exp(lambda self: self.by('Type'), doc="""\ A copy of self, but with 'Type' as the equivalence relation.""") byunity = property_exp(lambda self: self.by('Unity'), doc="""\ A copy of self, but with 'Unity' as the equivalence relation.""") byvia = property_exp(lambda self: self.by('Via'), doc=""" A copy of self, but with 'Via' as the equivalence relation.""") er = property_exp(lambda self: self.fam.get_er(self), doc="""\ The equivalence relation used for partitioning when representing / printing this set.""") count = property_exp(lambda self: len(self.nodes), doc="""\ The number of individual objects in the set.""") dominos = property_exp(lambda self: self.fam.View.dominos(self), doc="""\ The set 'dominated' by a set of objects. This is the objects that will become deallocated, directly or indirectly, when the objects in the set are deallocated. See also: domisize.""") domisize = property_exp(lambda self: self.fam.View.domisize(self), doc="""\ The dominated size of a set of objects. This is the total size of memory that will become deallocated, directly or indirectly, when the objects in the set are deallocated. See also: dominos, size. """) imdom = property_exp(lambda self: self.fam.View.imdom(self), doc="""\ The immediate dominators of a set of objects. The immediate dominators is a subset of the referrers. It includes only those referrers that are reachable directly, avoiding any other referrer.""") indisize = size = property_exp(lambda self: self.fam.View.indisize(self), doc="""\ The total 'individual' size of the set of objects. The individual size of an object is the size of memory that is allocated directly in the object, not including any externally visible subobjects. See also: domisize.""") kind = property_exp(lambda self: self.er[self], doc="""\ The kind of objects in the set. The kind is the union of the element-wise classifications as determined by the equivalence relation in use by the set.""") maprox = property_exp(lambda self: MappingProxy(self), doc="""\ An object that can be used to map operations to the objects in self, forming a new set of the result. The returned object is an instance of MappingProxy. This works currently as follows: o Getting an attribute of the MappingProxy object will get the attribute from each of the objects in the set and form a set of the results. If there was an exception when getting some attribute, it would be ignored. o Indexing the MappingProxy object will index into each of the objects in the set and return a set of the results. Exceptions will be ignored. Example: >>> hp.iso({'a':'b'}, {'a':1}).maprox['a'].byid Set of 2 objects. Total size = 40 bytes. Index Size % Cumulative % Kind: Name/Value/Address 0 28 70.0 28 70.0 str: 'b' 1 12 30.0 40 100.0 int: 1 >>> <This is an experimental feature, so the name is intentionally made mystically-sounding, and is a shorthand for 'mapping proxy'.>""") more = property_exp(lambda self: self.fam.get_more(self), doc="""\ An object that can be used to show more lines of the string representation of self. The object returned, a MorePrinter instance, has a string representation that continues after the end of the representation of self.""") all = property_exp(lambda self: self.fam.get_all(self), doc="""\ An object that can be used to show all lines of the string representation of self.""") owners = property_exp(lambda self: self.fam.get_owners(self), doc="""\ The set of objects that 'own' objects in self. The owner is defined for an object of type dict, as the object (if any) that refers to the object via its special __dict__ attribute.""") partition = property_exp(lambda self: self.fam.get_partition(self), doc="""\ A partition of the set of objects in self. The set is partitioned into subsets by equal kind, as given by a equivalence relation. Unless otherwise specified, the equivalence relation used is 'byclodo', which means it classifies 'by type or dict owner'. Different equivalence relations are specified for sets created by the 'by_...' attributes of any IdentitySet object. The value is an instance of guppy.heapy.Part.Partition.""") parts = property_exp(lambda self: self.fam.get_parts(self), doc="""\ An iterable object, that can be used to iterate over the 'parts' of self. The iteration order is determined by the sorting order the set has, in the table printed when partitioned.""") pathsin = property_exp(lambda self: self.get_shpaths(self.referrers), doc="""\ The paths from the direct referrers of the objects in self.""") pathsout = property_exp(lambda self: self.referents.get_shpaths(self), doc="""\ The paths to the referents of the objects in self.""") referents = property_exp(lambda self: self.fam.View.referents(self), doc="""\ The set of objects that are directly referred to by any of the objects in self.""") referrers = property_exp(lambda self: self.fam.View.referrers(self), doc="""\ The set of objects that directly refer to any of the objects in self.""") rp = property_exp(get_rp, doc="""\ rp: ReferencePattern An object representing the pattern of references to the objects in X. See also get_rp""") shpaths = property_exp(get_shpaths, doc="""x.shpaths: Paths An object containing the shortest paths to objects in x. Synonym sp See also get_shpaths""") shpaths = property_exp(get_shpaths, doc="""x.sp: Paths An object containing the shortest paths to objects in x. Synonym sp See also get_shpaths""") sp = property_exp(get_shpaths, doc="""x.sp: Paths An object containing the shortest paths to objects in x. Synonym shpaths See also get_shpaths""") stat = property_exp(lambda self: self.partition.get_stat(), doc="""\ x.stat: Stat An object summarizing the statistics of the partitioning of x. This is useful when only the statistics is required, not the objects themselves. The statistics can be dumped to a file, unlike the set of objects itself.""") theone = property_exp(lambda self: self.fam.get_theone(self), doc="""\ theone: Anything The one object in a singleton set. In case the set does not contain exactly one object, the exception ValueError will be raised. """) prod = property_exp(lambda self: self.fam.get_prod(self), doc="""\ theone: MorePrinter The traceback for the producer for the one object in a singleton set. """) class IdentitySetMulti(IdentitySet): __slots__ = 'nodes', def __init__(self, fam, nodes): super().__init__(fam) self.nodes = nodes class IdentitySetSingleton(IdentitySet): __slots__ = '_node', _help_url_ = 'heapy_UniSet.html#heapykinds.IdentitySetSingleton' def __init__(self, fam, node): super().__init__(fam) self._node = node # RefPat (eg) depends on this being usable as a hashable key. nodes = property_exp(lambda self: self.fam.immnodeset((self._node,)), doc="""\ x.nodes: ImmNodeSet The actual objects contained in x. These are called nodes because they are treated with equality based on address, and not on the generalized equality that is used by ordinary builtin sets or dicts.""") def _get_theone(self): return self._node theone = property_exp(_get_theone) class EquivalenceRelation(UniSet): """\ An equivalence relation is a binary relation between two elements of a set which groups them together as being "equivalent" in some way. An equivalence relation is reflexive, symmetric, and transitive. In other words, the following must hold for "~" to be an equivalence relation on X: Reflexivity: a ~ a * Symmetry: if a ~ b then b ~ a * Transitivity: if a ~ b and b ~ c then a ~ c. An equivalence relation partitions a set into several disjoint subsets, called equivalence classes. All the elements in a given equivalence class are equivalent among themselves, and no element is equivalent with any element from a different class. """ __slots__ = 'classifier', 'erargs' _help_url_ = 'heapy_UniSet.html#heapykinds.EquivalenceRelation' def __init__(self, fam, classifier, erargs=()): self.fam = fam self._hiding_tag_ = fam._hiding_tag_ self.classifier = classifier self.erargs = erargs self._origin_ = None def __getitem__(self, idx): return self.fam.c_getitem(self, idx) def _get_dictof(self): return self.fam.Classifiers.mker_dictof(self) dictof = property_exp(_get_dictof) def _get_refdby(self): return self.fam.Classifiers.mker_refdby(self) refdby = property_exp(_get_refdby) def sokind(self, args, kwds): return self.classifier.get_sokind(self, args, *kwds) class MappingProxy(object): __slots__ = '_set_', def __init__(self, set): self._set_ = set def __getattribute__(self, name): if name == '_set_': return object.__getattribute__(self, name) return self._set_.fam.maprox_getattr(self._set_, name) def __getitem__(self, name): return self._set_.fam.maprox_getitem(self._set_, name) class Family: supercl = None def __init__(self, mod): self.mod = mod self.Doc = mod._parent.Doc self._hiding_tag_ = mod._hiding_tag_ self.types = mod.types self.disjoints = mod.immnodeset() self.export_dict = self.mod.export_dict self.supers = mod.immnodeset([self]) self.Set = Kind def __call__(self, arg): return self.Set(self, arg) def _derive_origin_(self, origin): return self.Doc.add_origin(self, origin) def specotup(self, tup): r = self.Set(self, tup) r = self.Doc.add_origin(r, self.Doc.callfunc(self, tup)) return r def specoarg(self, arg): r = self.Set(self, arg) r = self.Doc.add_origin(r, self.Doc.callfunc(self, arg)) return r def specoargtup(self, arg, tup): r = self.Set(self, arg) r = self.Doc.add_origin(r, self.Doc.callfunc(self, tup)) return r def add_export(self, name, value): if self.export_dict is self.mod.export_dict: self.export_dict = self.mod.export_dict.copy() if name in self.export_dict and self.export_dict[name] is not value: raise ValueError('Duplicate: %s' % name) self.export_dict[name] = value def c_alt(self, a, cmp): raise ValueError('No alternative set for family %s.' % self) def c_binop(self, op, a, b): if not isinstance(b, UniSet): b = self.c_uniset(b) r = getattr(self, 'c_'+op)(a, b) # r = self.Doc.add_origin(r, self.Doc.binop(op, a.doc, b.doc)) return r def c_unop(self, op, a): r = getattr(self, 'c_'+op)(a) # r = self.Doc.add_origin(r, self.Doc.unop(op, a.doc)) return r def c_derive_origin(self, a, b): return self.Doc.add_origin(a, b) def c_call(self, a, args, kwds): raise ValueError('Not callable set') def c_contains(self, a, b): mod = self.mod return (a & mod.iso(b)) is not mod.Nothing def c_get_biper(self, a): return self.mod.Classifiers.biper(a) def c_get_dictof(self, a): return self.mod.Classifiers.dictof(a) def c_disjoint(self, a, b): # Determine if a, b are disjoint return (a & b) is self.mod.Nothing def c_factordisjoint(self, a, b): # Given a and b factors, and not a <= b and not b <= a, # determine if they are disjoint return getattr(self, '_factordisjoint_%s' % (b.fam.opname,))(a, b) def c_get_brief_alt(self, a, alt): return '[%s %s]' % (alt, self.c_get_brief(a)) def c_uniset(self, X): return self.mod.uniset_from_setcastable(X) def c_get_examples(self, a, env): return [] def c_getattr(self, a, b, args=(), kwds={}): d = self.export_dict if b in d: return d[b](a, args, *kwds) return self.c_getattr2(a, b) def c_getattr2(self, a, b): raise AttributeError(b) def c_get_render(self, a): return self.mod.summary_str.str_address def c_get_str_for(self, a, b): # A modification of str, for some cases, # when the set a is used as a determination of an idset b # Normally the same as brief, but.. 'dict of' will be different for eg module return a.brief def c_get_idpart_header(self, a): render = a.get_render() h = getattr(render, 'im_func', render) h = getattr(h, '_idpart_header', None) if not h: h = 'Value' return h def c_get_idpart_label(self, a): return '<%s>' % a def c_get_idpart_render(self, a): return self.c_get_render(a) def c_get_idpart_sortrender(self, a): render = self.c_get_idpart_render(a) if render is repr: return 'IDENTITY' h = getattr(render, 'im_func', render) render = getattr(h, '_idpart_sortrender', render) return render def c_hash(self, a): return hash(a.arg) def c_iter(self, a): raise TypeError('iteration over non-sequence') def c_len(self, a): raise TypeError('len() of unsized object') def c_nonzero(self, a): return True def c_mul(self, a, b): return self.mod._parent.Spec.cprod(a, b) def c_lshift(self, a, b): return self.Doc.add_origin(self.c_map(a, b), self.Doc.binop('lshift', a, b)) def c_map(self, a, b): if isinstance(b, list): b = tuple(b) if not isinstance(b, tuple): b = b, t = b + ('->', a) return self.mod._parent.Spec.mapping(t) def c_repr(self, a): return self.c_str(a) def c_str(self, a): return self.c_get_brief(a) def c_sub(self, a, b): return a & ~b def c_test_contains(self, a, b, env): if not self.c_contains(a, b): return env.failed('%s: %s does not contain %s' % (self.__class__, env.name(a), env.name(b))) return True def c_xor(self, a, b): return (a - b) \| (b - a) def _or_OR(self, a, b): return b.fam._or_TERM(b, a) def _rand_ATOM(self, a, b): return self._and_ATOM(a, b) class AtomFamily(Family): isatom = True isfactor = True opname = 'ATOM' def __init__(self, mod): Family.__init__(self, mod) self.disjoints \|= [self] def c_and(self, a, b): return b.fam._and_ATOM(b, a) def _and_ATOM(self, a, b): return self.mod.fam_And(a, b) def _and_AND(self, a, b): return b.fam._and_ATOM(b, a) def _and_FACTOR(self, a, b): return self.mod.fam_And(a, b) def _and_INVERT(self, a, b): return b.fam._and_ATOM(b, a) def _factordisjoint_ATOM(self, a, b): return (a.fam.disjoints & b.fam.supers or b.fam.disjoints & a.fam.supers) def _factordisjoint_INVERT(self, a, b): return b.fam._factordisjoint_ATOM(b, a) def c_le(self, a, b): return b.fam._ge_ATOM(b, a) _le_AND = _le_INVERT = _le_AND = c_le def _le_ATOM(self, a, b): # b is known to not be Nothing since its c_ge doesn't call back return self.supercl is not None and self.supercl <= b def c_ge(self, a, b): return b.fam._le_ATOM(b, a) _ge_INVERT = _ge_AND = c_ge def _ge_ATOM(self, a, b): # b is known to not be Nothing since its c_le doesn't call back return b.fam.supercl is not None and b.fam.supercl <= a def c_or(self, a, b): return b.fam._or_ATOM(b, a) def _or_ATOM(self, a, b): return self.mod.fam_Or(a, b) _or_AND = _or_INVERT = c_or def c_invert(self, a): return self.mod.fam_Invert(a) def defrefining(self, arg): self.supercl = arg self.supers \|= arg.fam.supers def defdisjoint(self, args): # Define disjointness of sets under the condition that # neither of them is a subset of the other (determined in some other way.) # I.E., define that there is no partial overlap. # Declare that all sets of my (self) family are disjoint under this condition # from all sets of each family in args. self.disjoints \|= args sc = self.supercl if sc is not None: self.disjoints \|= sc.fam.disjoints def defrefidis(self, arg): self.defrefining(arg) self.defdisjoint(arg.fam) def fam_union(self): return self.supercl class ArgAtomFamily(AtomFamily): def _and_ID(self, a, b): cla, k, cmp = self.c_get_ckc(a) return cla.select_ids(b, k, cmp) def _ge_ATOM(self, a, b): # b is known to not be Nothing since its c_le doesn't call back if self is b.fam: return a.arg == b.arg return b.fam.supercl is not None and b.fam.supercl <= a def _le_ATOM(self, a, b): # b is known to not be Nothing since its c_ge doesn't call back if self is b.fam: return a.arg == b.arg return self.supercl is not None and self.supercl <= b def c_get_ckc(self, a): return self.classifier, a.arg, '==' class AndFamily(Family): opname = 'AND' isatom = False isfactor = False def __call__(self, a, b): if a <= b: return a if b <= a: return b if a.fam.c_factordisjoint(a, b): return self.mod.Nothing return self._cons((a, b)) def _cons(self, arg): # We allow explicit non-normalized constructions, as an optimization # for a in arg: # assert a.fam.isatom or isinstance(a.fam, InvertFamily) if len(arg) > 1: return self.Set(self, tuple(arg)) elif len(arg) == 1: return arg[0] else: return self.mod.Nothing def c_get_examples(self, a, env): ex = [] for ai in a.arg: try: e = env.get_examples(ai) except CoverageError: pass else: for ei in list(e): for aj in a.arg: if aj is not ai: if not env.contains(aj, ei): break else: ex.append(ei) return ex def c_and(self, a, b): return b.fam._and_AND(b, a) def _and_AND(self, a, b): for b in b.arg: a &= b return a def _and_FACTOR(self, a, b): # a0 & a1 & ... & b xs = [] for ai in a.arg: if ai <= b: return a elif b <= ai: pass elif ai.fam.c_factordisjoint(ai, b): return self.mod.Nothing else: xs.append(ai) xs.append(b) return self._cons(xs) _and_ATOM = _and_INVERT = _and_FACTOR def _and_ID(self, a, b): b = a.arg[0] & b for a in a.arg[1:]: if b is self.mod.Nothing: break b = a & b return b def c_le(self, a, b): return b.fam._ge_AND(b, a) def _le_TERM(self, a, b): b = a & b if b.fam is not self or len(b.arg) != len(a.arg): return False for x in a.arg: for y in b.arg: if x <= y: break else: return False return True _le_ATOM = _le_INVERT = _le_AND = _le_TERM def c_ge(self, a, b): return b.fam._le_AND(b, a) def _ge_TERM(self, a, b): for a in a.arg: if not a >= b: return False return True _ge_ATOM = _ge_INVERT = _ge_AND = _ge_TERM def c_or(self, a, b): return b.fam._or_AND(b, a) def _or_AND(self, a, b): # a0 & a1 ... \| b0 & b1 ... # = Omega = ~self.mod.Nothing for i, ai in enumerate(a.arg): for j, bj in enumerate(b.arg): if ai \| bj == Omega: aa = self._cons(a.arg[:i] + a.arg[i+1:]) bb = self._cons(b.arg[:j] + b.arg[j+1:]) if aa == bb: return aa return self.mod.fam_Or(a, b) def _or_TERM(self, a, b): # a0 & a1 ... \| b if a <= b: return b if b <= a: return a xs = [] for ai in a.arg: aib = ai \| b if aib.fam.isfactor: xs.append(aib) else: break else: r = ~self.mod.Nothing for x in xs: r &= x return r return self.mod.fam_Or(a, b) _or_ATOM = _or_INVERT = _or_TERM def c_invert(self, a): # ~(a0 & a1 ...) = ~a0 \| ~a1 ... r = self.mod.Nothing for ai in a.arg: r \|= ~ai return r def c_contains(self, a, b): for x in a.arg: if b not in x: return False return True def c_test_contains(self, a, b, env): for x in a.arg: if not env.test_contains(x, b, 'and'): return env.failed('Failed') return True def c_disjoint3(self, a, b): return (a & b) is self.mod.Nothing def c_get_render(self, c): for kind in c.arg: r = kind.get_render() if r: return r def r(o): return hex(id(o)) return r def c_get_brief(self, c): names = [kind.brief for kind in c.arg] # names.sort() ?? I think now I want them in given order. return '(%s)' % ' & '.join(names) + ')' def c_get_ckc(self, a): return ( self.mod.Classifiers.mker_and([x.biper for x in a.arg]).classifier, (0,)len(a.arg), '==' ) def c_repr(self, a): reprs = [repr(k) for k in a.arg] return '(%s)' % ' & '.join(reprs) class OrFamily(Family): opname = 'OR' isatom = False isfactor = False def __call__(self, a, b): if b <= a: return a if a <= b: return b return self._cons((a, b)) def _cons(self, arg): # Must only be called with maximalized args for a in arg: assert a.fam.isfactor or isinstance(a.fam, AndFamily) if len(arg) > 1: return Family.__call__(self, tuple(arg)) elif len(arg) == 1: return arg[0] else: return self.mod.Nothing def c_contains(self, a, b): for x in a.arg: if b in x: return True return False def c_get_ckc(self, a): return self.mod.Use.findex(a.arg).classifier, len(a.arg), '<' def c_get_examples(self, a, env): exa = [iter(env.get_examples(x)) for x in a.arg] while 1: n = 0 for i, e in enumerate(exa): if e is not None: try: yield next(e) except StopIteration: exa[i] = None else: n += 1 if not n: break def c_test_contains(self, a, b, env): return env.forsome(a.arg, lambda x: env.test_contains(x, b, 'Some x'), 'or') def c_and(self, a, b): if self is b.fam: return self._and_OR(a, b) else: return self._and_TERM(a, b) def _and_TERM(self, a, b): # (a0 \| a1 ..) & b = a0 & b \| a1 & b \| ... r = self.mod.Nothing for a in a.arg: r \|= a & b return r _and_ATOM = _and_INVERT = _and_AND = _and_TERM def _and_OR(self, a, b): # (a0 \| a1 ..) & (b0 \| b1 ..) = a0 & b0 \| a0 & b1 ... a1 & b0 \| a1 & b1 ... r = self.mod.Nothing for a in a.arg: for bi in b.arg: r \|= a & bi return r def _and_ID(self, a, b): ai = a.arg[0] r = ai.fam._and_ID(ai, b) for ai in a.arg[1:]: r \|= ai.fam._and_ID(ai, b) return r def _ge_TERM(self, a, b): a = a & b if a.fam is self: if b.fam is not a.fam or len(b.arg) != len(a.arg): return False assert 0 else: return b <= a _ge_ATOM = _ge_INVERT = _ge_AND = _ge_TERM def c_ge(self, a, b): if b.fam is self: return self.c_le(b, a) else: return self._ge_TERM(a, b) def c_le(self, a, b): for x in a.arg: if not x <= b: return False return True _le_ATOM = _le_INVERT = _le_AND = c_le def c_or(self, a, b): return b.fam._or_OR(b, a) def _or_TERM(self, a, b): # a0 \| a1 ... \| b xs = [] lt = False for a in a.arg: if not b >= a: xs.append(a) if b <= a: lt = True if not lt: xs.append(b) return self._cons(xs) _or_ATOM = _or_INVERT = _or_AND = _or_TERM def _or_OR(self, a, b): # (a0 \| a1 ...) \| (b0 \| b1 ...) xs = maximals(a.arg + b.arg) return self._cons(xs) def c_invert(self, a): # ~(a0 \| a1 ...) = ~a0 & ~a1 ... r = ~a.arg[0] for ai in a.arg[1:]: r &= ~ai return r def c_get_render(self, c): renders = self.mod.mutnodeset([kind.get_render() for kind in c.arg]) if len(renders) == 1: return list(renders)[0] else: def r(o): return hex(id(o)) r._idpart_header = 'Address' r._idpart_sortrender = lambda x: id(x) return r def c_get_brief(self, c): names = [kind.brief for kind in c.arg] names.sort() return '(' + ' \| '.join(names) + ')' def c_get_idpart_header(self, a): return 'Brief' def c_get_idpart_label(self, a): return '<mixed>' def c_get_idpart_render(self, a): er = self.mod.Use.Clodo cla = er.classifier cli = cla.cli brmemo = {} def render(x): k = cli.classify(x) br = brmemo.get(k) if br is None: kind = cla.get_kind(k) b = cla.get_kind(k).brief r = kind.get_render() br = (b, r) brmemo[k] = br b, r = br return '%s: %s' % (b, r(x)) return render def c_get_idpart_sortrender(self, a): er = self.mod.Use.Clodo cla = er.classifier cli = cla.cli brmemo = {} def render(x): k = cli.classify(x) br = brmemo.get(k) if br is None: kind = cla.get_kind(k) b = cla.get_kind(k).brief r = kind.fam.c_get_idpart_sortrender(kind) br = (b, r) brmemo[k] = br else: b, r = br if r != 'IDENTITY': x = r(x) return (b, x) return render def c_repr(self, a): reprs = [repr(k) for k in a.arg] reprs.sort() return '(%s)' % ' \| '.join(reprs) class InvertFamily(Family): opname = 'INVERT' isatom = False isfactor = True def __call__(self, a): assert a.fam.isatom if a is self.mod.Nothing: return self.mod.NotNothing else: return Family.__call__(self, a) def c_test_contains(self, a, b, env): return env.test_contains_not(a.arg, b, 'InvertFamily') def c_contains(self, a, b): return not b in a.arg def c_and(self, a, b): return b.fam._and_INVERT(b, a) _and_AND = c_and def _and_FACTOR(self, a, b): # ~a.arg & ~b.arg # ~a.arg & b # Is normal form? x = a.arg & b if x.fam.isatom: a = self(x) return self.mod.fam_And(a, b) _and_ATOM = _and_INVERT = _and_FACTOR def _and_ID(self, a, b): return b - (b & a.arg) def _factordisjoint_ATOM(self, a, b): # ~ a.arg <disjoint> b return b <= a.arg def _factordisjoint_INVERT(self, a, b): # ~ a.arg <disjoint> ~b.arg return False def c_le(self, a, b): return b.fam._ge_INVERT(b, a) _le_AND = c_le def _le_ATOM(self, a, b): # ~a.arg <= b return False def _le_INVERT(self, a, b): # ~a.arg <= ~b.arg return b.arg <= a.arg def c_ge(self, a, b): # ~a.arg >= b return a.arg.disjoint(b) _ge_ATOM = _ge_INVERT = _ge_AND = c_ge def c_or(self, a, b): return b.fam._or_INVERT(b, a) _or_AND = c_or def _or_FACTOR(self, a, b): # ~a.arg \| b if a.arg <= b: return ~self.mod.Nothing x = a.arg & b if x is self.mod.Nothing: return a return self.mod.fam_Or(a, b) _or_ATOM = _or_INVERT = _or_FACTOR def c_invert(self, a): # ~(~a.arg) = a.arg return a.arg def c_get_render(self, a): return a.arg.get_render() def c_get_brief(self, a): n = a.arg.brief if (not (n.startswith('(') or n.startswith('<')) and ' ' in n): n = '(%s)' % n return '~%s' % n def c_get_ckc(self, a): # This uses only existing machinery for C-level classification. # The alternatives are discussed in Notes 21 Sep 2005. return ( a.arg.biper.classifier, 0, '!=' ) def c_repr(self, a): return '~%s' % repr(a.arg) class FamilyFamily(AtomFamily): def __init__(self, mod): AtomFamily.__init__(self, mod) self.add_export('union', lambda x: x.arg.fam_union()) def c_contains(self, a, b): return isinstance(b, UniSet) and b.fam is a.arg def c_get_brief(self, c): return '<Family: %s>' % c.arg.__class__ class IdentitySetFamily(AtomFamily): def __init__(self, mod): AtomFamily.__init__(self, mod) self.defrefining(mod.Anything) self.immnodeset = mod.immnodeset self.Part = mod.Part self.Path = mod.Path self.RefPat = mod.RefPat self.View = mod.View self.Use = mod.Use def __call__(self, args, kwds): return self._cons(args, kwds) def _cons(self, arg, er=None): # arg is a sequence of nodes arg = self.immnodeset(arg) if not arg: return self.mod.Nothing elif len(arg) == 1: r = IdentitySetSingleton(self, tuple(arg)[0]) else: r = IdentitySetMulti(self, arg) if er is not None: r._er = er return r def c_and(self, a, b): if b.fam is self: return self._cons(a.nodes & b.nodes) elif b.fam is self.mod.fam_Invert: return self._and_INVERT(a, b) else: return b.fam._and_ID(b, a) def _and_ATOM(self, a, b): if b.fam is self: return self._cons(a.nodes & b.nodes) else: return b.fam._and_ID(b, a) def _and_AND(self, a, b): return b.fam._and_ID(b, a) def _and_ID(self, a, b): return self._cons(a.nodes & b.nodes) def _and_INVERT(self, a, b): if b.arg.fam is self: return self._cons(a.nodes - b.arg.nodes) elif b is self.mod.NotNothing: return a else: return b.fam._and_ID(b, a) def c_get_ckc(self, a): return self.mod.Classifiers.Idset.classifier, a.nodes, '<=' def c_hash(self, a): return hash(a.nodes) def c_iter(self, a): # It's not well-defined to iterate and is considered error-prone # and may be SO much slower than expected # they need to be explicit to iterate over elements or partition subset raise TypeError('iteration over non-sequence') def c_len(self, a): # The length corresponds to # o the number of rows in how it is printed # o the max getitem-wise index + 1 # (Notes May 13 2005) return a.partition.numrows def c_contains(self, a, b): return b in a.nodes def c_le(self, a, b): if not b.fam is self: b = b.fam._and_ID(b, a) return a.nodes <= b.nodes _le_ATOM = _le_INVERT = _le_AND = c_le def c_or(self, a, b): if b.fam is self: return self._cons(a.nodes \| b.nodes) else: a = a - b.fam._and_ID(b, a) return b.fam._or_ATOM(b, a) _or_ATOM = _or_INVERT = _or_AND = _or_OR = c_or def c_get_brief(self, c): return self.get_str_summary(c) def c_get_render(self, a): return a.kind.get_render() def c_getitem(self, a, idx): return a.partition.get_set(idx) def c_str(self, a): return a.more._oh_printer.get_str_of_top() def maprox_getattr(self, set, name): ns = self.mod.mutnodeset() for x in set.nodes: try: v = getattr(x, name) except AttributeError: pass else: ns.add(v) return self._cons(self.mod.immnodeset(ns)) def maprox_getitem(self, set, idx): ns = self.mod.mutnodeset() for x in set.nodes: try: v = x[idx] except (KeyError, IndexError): pass else: ns.add(v) return self._cons(self.mod.immnodeset(ns)) def c_get_idpart_header(self, a): return 'Kind: Name/Value/Address' def c_get_idpart_label(self, a): return '' def c_get_idpart_render(self, a): def render(x): x = self.mod.iso(x) r = x.brief.lstrip('<1 ').rstrip('>') return r return render def get_by(self, a, er): ers = [] if isinstance(er, EquivalenceRelation): ers.append(er) else: try: ss = er.split('&') except Exception: raise TypeError( 'by(): Equivalence relation or string expected.') if ss == ['']: ss = [] for s in ss: try: if not s.istitle() or s.startswith('er_'): s = 'er_'+s er = getattr(self.Use, s) except AttributeError: raise ValueError( 'by(): No such equivalence relation defined in heapy.Use: %r' % s) ers.append(er) if not ers: er = self.Use.Unity else: er = ers[0] for i in range(1, len(ers)): er &= ers[i] if a.er is not er: a = self._cons(a.nodes, er=er) return a def get_er(self, a): try: er = a._er except AttributeError: er = self.mod.Use.Clodo a._er = er return er def get_more(self, a): try: m = a._more except AttributeError: m = self.mod.OutputHandling.more_printer(a, a.partition) a._more = m return m def get_all(self, a): return a.more.all def get_owners(self, a): return self.mod.Use.Clodo.classifier.owners(a) def get_partition(self, a): try: p = a._partition except AttributeError: a.fam.View.clear_check() p = a.fam.Part.partition(a, a.er) a._partition = p return p def get_str_idpart(self, set, cla): # Get the string that is used for the 'identity partition' # when the objects share a common classification (cla) s = cla.fam.c_get_str_for(cla, set) return s def get_str_refpat(self, set, cla, max_length): # Get the string that is used at the end of a reference pattern line strs = [] strs.append('%d ' % set.count) strs.append(cla.fam.c_get_str_for(cla, set)) strs.append(': ') strs.append(self.get_str_rendered( set, cla, max_length-len(''.join(strs)))) s = ''.join(strs) if len(s) > max_length: s = s[:max_length - 3]+'...' return s def get_str_rendered(self, set, cla, max_length=None): if max_length is None: max_length = 50 strs = [] lens = 0 render = cla.get_render() for p in set.nodes: rs = render(p) if lens and lens + len(rs) + 2 >= max_length: strs[-1] += '...' # but what can be done in limited time break lens += len(rs) + 2 strs.append(rs) strs.sort() return ', '.join(strs) def get_str_summary(self, c, max_length=None, er=None): if max_length is None: max_length = self.mod.max_summary_length if er is None: er = c.er set = c.nodes items = er.classifier.partition(set) keys = [k for k, v in items] cla = reduce(lambda x, y: x \| y, keys) s = '<%d %s' % (len(set), cla.fam.c_get_str_for(cla, c)) s += ': ' bslen = len(s) bstrs = [] for cla, set in items: css = self.get_str_rendered(set, cla, max_length-bslen) if len(items) > 1: css = '<%d %s: %s>' % (set.count, cla, css) bstrs.append(css) bslen += len(css) + 3 if bslen > max_length: break # Don't use the initial count when comparing if len(bstrs) > 1: bstrs.sort(key=lambda x: x[x.index(' '):]) s += ' \| '.join(bstrs) + '>' if len(s) > max_length: s = s[:max_length-4]+'...>' return s def get_parts(self, X): return [x for x in X.partition.get_sets()] def get_theone(self, set): if len(set.nodes) == 1: return list(set.nodes)[0] raise ValueError('theone requires a singleton set') def get_prod(self, set): obj = self.get_theone(set) self.mod.Use._check_tracemalloc() tb = self.mod.tracemalloc.get_object_traceback(obj) if tb is None: return try: frames = tb.format(most_recent_first=True) except TypeError: # Py < 3.7 frames = tb.format() # TODO: move to a delicated file class Printer: def _oh_get_line_iter(self): yield 'Traceback (most recent call first):' yield from frames printer = Printer() printer.mod = self.mod self.mod.OutputHandling.setup_printing(printer) return printer class EmptyFamily(IdentitySetFamily): # Inherits from IdentitySetFamily because the special exported methods # tend to be required by applications. # There is only one object of EmptyFamily: UniSet.Nothing # The new method implementations added here are mostly for optimization. # (Other families may assume the EmptyFamily have these methods.) # The .nodes is an empty immnodeset so IdentitySetFamily methods should work. # The main change from IdentitySetFamily is the representations. def __init__(self, mod): IdentitySetFamily.__init__(self, mod) def c_and(self, a, b): return a _and_ATOM = _and_INVERT = _and_AND = _and_OR = _and_ID = c_and def c_contains(self, a, b): return False def c_ge(self, a, b): if b is a: return True return False _ge_ATOM = _ge_INVERT = _ge_AND = c_ge def c_get_brief(self, a): return '<Nothing>' def c_repr(self, a): return '%s%s' % (self.mod.Use.reprefix, 'Nothing') def c_iter(self, a): return iter(()) def c_le(self, a, b): return True _le_ATOM = _le_INVERT = _le_AND = c_le def c_len(self, a): return 0 def c_nonzero(self, a): return False def c_or(self, a, b): return b _or_ATOM = _or_INVERT = _or_AND = _or_OR = c_or def c_str(self, a): return self.c_get_brief(a) def c_sub(self, a, b): return a def c_xor(self, a, b): return b class EquivalenceRelationFamily(AtomFamily): def __init__(self, mod): AtomFamily.__init__(self, mod) self.Set = EquivalenceRelation self.Use = mod.Use self.Classifiers = mod.Classifiers def __call__(self, constructor, args, kwds): # Passing classifier constructor rather than constructed classifier, # to make sure there is a 1-1 relation between equivalence relations and classifers. cl = constructor(args, *kwds) er = self.Set(self, cl) cl.er = er return er def c_contains(self, a, b): # XXX should have a smoother protocol try: return len(b.by(a)) == 1 except AttributeError: try: ckc = b.get_ckc() except Exception: return False else: return ckc[0].er <= a and ckc[2] == '==' def c_getattr(self, a, name): classifier = a.classifier try: g = getattr(classifier, 'get_attr_for_er') except AttributeError: raise AttributeError(name) return g(name) def c_and(self, a, b): if b.fam is not self: return AtomFamily.c_and(self, a, b) ers = [] for x in (a, b): if x.erargs: ers.extend(x.erargs) else: ers.append(x) ers = minimals(ers) if len(ers) == 1: return ers[0] er = self.Classifiers.mker_and(ers) er.erargs = tuple(ers) return er def _ge_ATOM(self, a, b): if b.fam is self: return a.classifier in b.classifier.super_classifiers return False def _le_ATOM(self, a, b): if b.fam is self: return b.classifier in a.classifier.super_classifiers return False def c_call(self, a, args, kwds): return a.classifier.get_userkind(args, *kwds) def c_get_brief(self, a): return 'Equiv. relation %s' % a.classifier def c_getitem(self, a, idx): return a.classifier.relimg(self.mod.nodeset_adapt(idx)) def c_repr(self, a): return a.classifier.get_reprname() class Summary_str: def __init__(self, mod): self.mod = mod types = mod.types._module self.invtypes = {} for k, v in sorted(types.__dict__.items()): if isinstance(v, type): self.invtypes[v] = 'types.%s' % k for k, v in sorted(types.__builtins__.items()): if isinstance(v, type): self.invtypes[v] = k # This is to make common printouts prettier / shorter (: and clearer ? :) # but may be disabled for clearer repr() self.shorter_invtypes = {} for name in ('module', 'function'): t = getattr(types, name.capitalize()+'Type') self.shorter_invtypes[t] = name self.table = { mod.NodeSet: self.str_address_len, bool: self.str_repr, types.BuiltinFunctionType: self.str_builtin_function, types.CodeType: self.str_code, complex: self.str_repr, dict: self.str_address_len, float: self.str_repr, types.FrameType: self.str_frame, types.FunctionType: self.str_function, int: self.str_repr, list: self.str_address_len, type(None): self.str_repr, types.MethodType: self.str_method, types.ModuleType: self.str_module, types.TracebackType: self.str_traceback, bytes: self.str_limrepr, str: self.str_limrepr, tuple: self.str_address_len, type: self.str_type, } def __call__(self, key, longer=False): x = self.table.get(key) if x is None: if issubclass(key, type): x = self.str_type else: x = self.str_address if longer and 'longer' in x.__func__.__code__.co_varnames: return lambda k: x(k, longer=longer) else: return x def set_function(self, type, func): self.table[type] = func def str_address(self, x): return hex(id(x)) str_address._idpart_header = 'Address' str_address._idpart_sortrender = id def str_address_len(self, x): return self.str_address(x)+self.str_len(x) str_address_len._idpart_header = 'AddressLength' str_address_len._idpart_sortrender = id def str_builtin_function(self, x): n = x.__name__ m = x.__module__ if m != 'builtins': n = '%s.%s' % (m, n) return n str_builtin_function._idpart_header = 'Name' def str_code(self, x): return '%s:%d:%s' % (self.mod._root.os.path.basename(x.co_filename), x.co_firstlineno, x.co_name) str_code._idpart_header = 'File:Line:Name' def str_frame(self, x): return '<%s at %s>' % (x.f_code.co_name, self.str_address(x)) str_frame._idpart_header = 'Name at Address' def str_function(self, x): return '%s.%s' % (x.__module__, x.__name__) str_function._idpart_header = 'Name' def str_len(self, x): return '%d' % len(x) str_len._idpart_header = 'Length' def str_method(self, x): cn = self.str_type(x.__self__.__class__) if x.__self__ is not None: cn = '<%s at %s>' % (cn, self.str_address(x.__self__)) func = x.__func__ try: func_name = func.__func__ except AttributeError: func_name = func.__name__ return '%s.%s' % (cn, func_name) str_method._idpart_header = 'Type/<Type at address> . method' def str_module(self, x): return x.__name__ str_module._idpart_header = 'Name' def str_limrepr(self, x): return self.mod._root.reprlib.repr(x) str_limrepr._idpart_header = 'Representation (limited)' str_limrepr._idpart_sortrender = 'IDENTITY' str_repr = repr def str_traceback(self, x): return '<in frame %s at %s>' % (self.str_frame(x.tb_frame), self.str_address(x)) str_traceback._idpart_header = 'Frame at Address' def str_type(self, x, longer=False): if x in self.shorter_invtypes and not longer: return self.shorter_invtypes[x] if x in self.invtypes: return self.invtypes[x] if not hasattr(x, '__module__'): return f'<unknown module>.{x.__name__}' return f'{x.__module__}.{x.__name__}' str_type._idpart_header = 'Name' def str_type_longer(self, x): if x in self.invtypes: return self.invtypes[x] return '%s.%s' % (x.__module__, x.__name__) str_type._longer_method = lambda x: str_type def maximals(A, le=lambda x, y: x <= y): " Find the maximal element(s) of a partially ordered sequence" r = [] for x in A: for a in A: if le(x, a) and not le(a, x): break else: for a in r: if le(x, a): break else: r.append(x) return r def minimals(A, le=lambda x, y: x <= y): " Find the minimal element(s) of a sequence of partially ordered elements" r = [] for x in A: for a in A: if le(a, x) and not le(x, a): break else: for a in r: if le(a, x): break else: r.append(x) return r class _GLUECLAMP_: max_summary_length = 80 auto_convert_type = True auto_convert_iter = False # Can give problems if enabled; notes 22/11-04 out_reach_module_names = ('UniSet', 'View', 'Path', 'RefPat') _chgable_ = ('max_summary_length', 'out_reach_module_names', 'auto_convert_type', 'auto_convert_iter', 'output') # _preload_ = ('_hiding_tag_',) # Module 'imports' _imports_ = ( '_parent:Classifiers', '_parent:ImpSet', '_parent.ImpSet:emptynodeset', '_parent.ImpSet:immnodeset', '_parent.ImpSet:mutnodeset', '_parent.ImpSet:NodeSet', '_parent:Part', '_parent:Path', '_parent:RefPat', '_parent:OutputHandling', '_parent:View', '_parent.View:_hiding_tag_', '_parent.View:hv', '_parent:Use', '_root:tracemalloc', '_root:types', ) # def _get_Anything(self): return self.Use.Unity.classifier.get_kind(None) def _get_Nothing(self): return IdentitySetMulti( EmptyFamily(self), self.emptynodeset) def _get_NotNothing(self): return Family.__call__( self.fam_Invert, self.Nothing) def _get_export_dict(self): d = {} for k, v in list(self.out_reach_dict.items()): sc = getattr(v, '_uniset_exports', ()) for sc in sc: x = getattr(v, sc) if sc in d and d[sc] is not x: raise RuntimeError( 'Duplicate export: %r defined in: %r' % (sc, k)) d[sc] = x return d def _get_out_reach_dict(self): d = {} for name in self.out_reach_module_names: d[name] = getattr(self._parent, name) return d def _get_summary_str(self): return self.Summary_str(self) def _get_fam_And(self): return self.AndFamily(self) def _get_fam_EquivalenceRelation( self): return EquivalenceRelationFamily(self) def _get_fam_Or(self): return self.OrFamily(self) def _get_fam_IdentitySet(self): return self.IdentitySetFamily(self) def _get_fam_Invert(self): return self.InvertFamily(self) def _get_fam_Family(self): return self.FamilyFamily(self) def _get_fam_mixin_argatom(self): memo = {} def f(Mixin, args, *kwds): C = memo.get(Mixin) if C is None: class C(Mixin, self.ArgAtomFamily): def __init__(self, mod, args, *kwds): mod.ArgAtomFamily.__init__(self, mod) Mixin.__init__(self, mod, args, *kwds) C.__qualname__ = C.__name__ = Mixin.__name__ memo[Mixin] = C return C(self, args, **kwds) return f def idset_adapt(self, X): if isinstance(X, self.IdentitySet): ids = X elif isinstance(X, self.NodeSet): ids = self.idset(X) else: raise TypeError( 'IdentitySet or NodeSet expected, got %r.' % type(X)) if X._hiding_tag_ is not self._hiding_tag_: raise ValueError( "The argument has wrong _hiding_tag_, you may convert it by Use.idset or Use.iso.") return ids def idset(self, iterable, er=None): return self.fam_IdentitySet._cons(self.immnodeset(iterable), er=er) def _get_iso(self): return self.fam_IdentitySet def isuniset(self, obj): return isinstance(obj, self.UniSet) # Or has some particular attributes? def nodeset_adapt(self, X): if isinstance(X, self.NodeSet): ns = X elif isinstance(X, self.IdentitySet): ns = X.nodes else: raise TypeError( 'IdentitySet or NodeSet expected, got %r.' % type(X)) if X._hiding_tag_ is not self._hiding_tag_: raise ValueError( "The argument has wrong _hiding_tag_, you may convert it by Use.idset or Use.iso.") return ns def retset(self, X): if not isinstance(X, self.IdentitySet): X = self.idset(X) return X def union(self, args, maximized=False): if not args: return self.Nothing a = args[0] for b in args[1:]: a \|= b return a # This optimization didn't work for idsets!! # XXX to fix back if not maximized: args = maximals(args) return self.fam_Or._cons(args) def uniset_from_setcastable(self, X): if isinstance(X, UniSet) and X._hiding_tag_ is self._hiding_tag_: return X types = self.types if isinstance(X, type) and self.auto_convert_type: return self.Use.Type(X) elif isinstance(X, self.NodeSet) and X._hiding_tag_ is self._hiding_tag_: return self.idset(X) elif self.auto_convert_iter: try: it = iter(X) except TypeError: pass # Will raise a 'more informative' exception below else: return self.idset(it) raise TypeError( "Argument is not automatically convertible to a UniSet with correct _hiding_tag_.")	66.5 KB	2026-01-20 12:58
📄 Use.py import guppy.etc.Glue class _GLUECLAMP_(guppy.etc.Glue.Interface): _preload_ = '_hiding_tag_', _chgable_ = ('reprefix', 'default_reprefix', 'gcobjs', 'relheap', 'relheapg', 'relheapu', '__doc__') _dir_ = ( 'Anything', 'Clodo', 'Id', 'Idset', 'Module', 'Nothing', 'Prod', 'Rcs', 'Root', 'Size', 'Type', 'Unity', 'Via', 'doc', 'findex', 'heap', 'heapu', 'idset', 'iso', 'load', 'monitor', 'pb', 'setref', 'test') _private_ = ('View', '_hiding_tag_', '_load_stat', '_check_tracemalloc', 'ctime', 'default_reprefix', 'dumph', 'gcobjs', 'heapg', 'loadc', 'relheap', 'relheapg', 'relheapu', 'reprefix', 'setrelheap', 'setrelheapg', 'setrelheapu', 'tc_adapt', 'tc_repr', 'union', 'uniset_from_setcsatable', 'warnings', 'Stat' ) default_reprefix = 'hpy().' def _get_gcobjs(self): return self.Nothing def _get_relheap(self): return self.Nothing def _get_relheapg(self): return self.Nothing def _get_relheapu(self): return self.Nothing def _get_reprefix(self): # The name that this instance (or one with the same ._share) # has in the __main__ module, if any, or self.default_reprname otherwise. # Used for prefixing the result of repr() of various objects # so it becomes possible to evaluate it in a typical environment. import __main__ for k, v in list(__main__.__dict__.items()): if (isinstance(v, self.__class__) and getattr(v, '_share', None) is self._share): return '%s.' % k return self.default_reprefix def _get_Root(self): """Root: RootStateType This attribute is a symbolic root containing attributes from which all reachable objects in the heap can be reached. It is the only value (a singleton) of its kind; see [1] for a description of its attributes. References [0] heapy_Use.html#heapykinds.Use.Root [1] heapy_RootState.html#heapykinds.RootStateType""" return self.View.heapyc.RootState def __repr__(self): return """\ Top level interface to Heapy. Use eg: %sdoc for more info on %s.""" % ( self.reprefix, self.reprefix[:-1]) def Ddir(self, opts=''): """\ #OBSOLETE $HP.dir(opts: str+])-> GuppyDir $HP.dir(opts: str+]).<attribute> -> GuppyDoc A replacement for the builtin function dir(), providing a listing of public attributes for Heapy objects. It also has an attribute for each item in the listing, for example: >>> $HP.dir().heap returns a GuppyDoc object providing documentation for the heap method. The method also takes a string argument specifying further options. Currently the following are provided: 'l' Generate a listing of the synopsis lines. 'L' Generate a listing of the entire doc strings.""" obj = self return self._root.guppy.etc.Help.dir(obj, opts) def _get_doc(self): """Overview documentation for top level Heapy object. Provides a listing of the available attributes. Accessing the attribute name on the doc objects gives further info, eg: >>> hp.doc.heap gives doc for the heap method when hp is the top level Heapy object. References may be embedded in the documentations. To access a reference, opening up a web browser with the doc for it one can do eg: >>> hp.doc.heap[1] The reference number 0 is special. If it is provided, it is the reference to the html doc for the described object itself. So to see in the web browser the doc for the heap method one can do: >>> hp.doc.heap[0] References [0] heapy_Use.html#heapykinds.Use.doc""" return self._root.guppy.etc.Help.dir(self, header="""\ Top level interface to Heapy. Available attributes:""", footer="""\ Use eg: %sdoc.<attribute> for info on <attribute>.""" % self.reprefix) def _check_tracemalloc(self): if self.sys.version_info < (3, 8): self.warnings.warn( "Python 3.7 and below tracemalloc may not record accurate " "producer trace. See https://bugs.python.org/issue35053") if not self.tracemalloc.is_tracing(): raise RuntimeError( "Tracemalloc is not tracing. No producer profile available. " "See https://docs.python.org/3/library/tracemalloc.html") def heapg(self, rma=1): """ DEPRECATED """ self.warnings.warn( "Method Use.heapg is depreciated, it doesn't work well. Use heapu instead.") h = self.View.heapg(rma) h -= self.relheapg return h def heapu(self, rma=1, abs=0, stat=1): """heapu() -> Stat Finds the objects in the heap that remain after garbage collection but are _not_ reachable from the root. This can be used to find objects in extension modules that remain in memory even though they are gc-collectable and not reachable. Returns an object containing a statistical summary of the objects found - not the objects themselves. This is to avoid making the objects reachable. See also: setref[1] References [0] heapy_Use.html#heapykinds.Use.heapu [1] heapy_Use.html#heapykinds.Use.setref""" h = self.View.heapu(rma) rel = 0 if not abs and self.relheapu and isinstance(self.relheapu, type(h)): h -= self.relheapu rel = 1 if stat: h = h.stat if not abs and self.relheapu and isinstance(self.relheapu, type(h)): h -= self.relheapu rel = 1 h.firstheader = 'Data from unreachable objects' if rel: h.firstheader += ' relative to: %s' %\ self.ctime(self.relheapu.timemade) h.firstheader += '.\n' return h def heap(self): """heap() -> IdentitySet[1] Traverse the heap from a root to find all reachable and visible objects. The objects that belong to a heapy instance are normally not included. Return an IdentitySet with the objects found, which is presented as a table partitioned according to a default equivalence relation (Clodo [3]). See also: setref[2] References [0] heapy_Use.html#heapykinds.Use.heap [1] heapy_UniSet.html#heapykinds.IdentitySet [2] heapy_Use.html#heapykinds.Use.setref [3] heapy_Use.html#heapykinds.Use.Clodo""" h = self.View.heap() h \|= self.gcobjs h -= self.relheap return h def load(self, fn, use_readline=0): """\ load(alt:[fn: loadablefilenamestring+ or fn: loadableiterableofstrings+] [use_readline = boolean+]) -> Stat Load heapy-related data from a serialized form. Currently it handles data generated by Stat.dump. Arguments fn: loadablefilenamestring+ A string argument is treated as a file name. fn: loadableiterableofstrings+ An open file or an iterator will be iterated over enough to read one package of data, and another call to load will read the next package. use_readline = boolean+ If true, the method will use .readline() instead of iteration, which may be necessary in case the input comes from a pipe since otherwise the Python runtime would try to read ahead a big block before returning the first package of data. Returns one package of statistical data. References [0] heapy_Use.html#heapykinds.Use.load""" if isinstance(fn, str): # We got a filename. # I want to read only what is being requested # so I can look quickly at some lines of a long table. # (There are seemingly easier ways to do this # but this takes care of some tricky details. # Keeping f open avoids it to be overwritten # (at least by Stat.dump() and if OS=Linux) # if data are written to a new file with the same name.) f = open(fn) def get_trows(): pos = 0 while 1: f.seek(pos) line = f.readline() if not line: break pos = f.tell() yield line elif hasattr(fn, '__iter__') and not hasattr(fn, '__next__'): # We got a sequence, that is not an iterator. Use it directly. def get_trows(): return fn elif hasattr(fn, '__next__'): # We got an iterator or file object. # We 'have' to read all lines (at once)- # to update the read position - # to mimic 'pickle' semantics if several # objects are stored in the same file. # We can't use .__next__ always - (eg not on pipes) # it makes a big readahead (regardless of buffering setting). # But since .__next__() (typically) is much faster, we use it # per default unless use_readline is set. if use_readline: get_line = fn.readline else: get_line = fn.__next__ trows = [] line = get_line() if not line: raise StopIteration endline = '.end: %s' % line try: while line: trows.append(line) if line == endline: break line = get_line() else: raise StopIteration except StopIteration: trows.append(endline) def get_trows(): return trows else: raise TypeError( 'Argument should be a string, file or an iterable yielding strings.') a = next(iter(get_trows())) if not a.startswith('.loader:'): raise ValueError( 'Format error in %r: no initial .loader directive.' % fn) loader = a[a.index(':')+1:].strip() try: loader = getattr(self, loader) except AttributeError: raise ValueError( 'Format error in %r: no such loader: %r.' % (fn, loader)) return loader(get_trows) def loadall(self, f): ''' Generates all objects from an open file f or a file named f''' if isinstance(f, str): f = open(f) while True: yield self.load(f) def loadc(self, fn): f = open(fn, 'r', 1) while 1: print(self.load(f, use_readline=1)) def dumph(self, fn): f = open(fn, 'w') import gc while 1: x = self.heap() x.stat.dump(f) f.flush() print(len(gc.get_objects())) def setref(self, reachable=None, unreachable=None): """setref() Set a reference point for heap usage measurement. This applies to both the heap[1] and heapu[2] methods. The heap() method will only show the objects allocated after the time setref was called. The heapu() method, since it deals with summary data and not actual objects, will show the difference of sizes and counts compared to when setref was called. References [0] heapy_Use.html#heapykinds.Use.setref [1] heapy_Use.html#heapykinds.Use.heap [2] heapy_Use.html#heapykinds.Use.heapu""" if reachable is None and unreachable is None: self.setrelheap() self.setrelheapu() else: if reachable is not None: self.setrelheap(reachable) if unreachable is not None: self.setrelheapu(unreachable) def setrelheap(self, reference=None): if reference is None: reference = self.View.heap() self.relheap = reference def setrelheapg(self, reference=None): self.warnings.warn( "Method Use.setrelheapg is depreciated, use setref instead.") if reference is None: self.relheapg = None reference = self.View.heapg() self.relheapg = reference def setrelheapu(self, reference=None, stat=1): if reference is None: self.relheapu = None reference = self.heapu(abs=True, stat=stat) if stat and not isinstance(reference, self.Stat): reference = reference.stat self.relheapu = reference def test(self, debug=False): """test([debug: bool+ = False]) Run the Heapy test suite. Argument debug If True, the tests will be run in debug mode so the stack frame can be examined with pdb.pm() after the first exception.""" self._parent.test.test_all.test_main(debug) _imports_ = ( '_parent.Classifiers:Clodo', '_parent.Classifiers:Id', '_parent.Classifiers:Idset', '_parent.Classifiers:Module', '_parent.Classifiers:Prod', '_parent.Classifiers:Rcs', '_parent.Classifiers:Size', '_parent.Classifiers:Type', '_parent.Classifiers:Unity', '_parent.Classifiers:Via', '_parent.Classifiers:findex', '_parent.Classifiers:sonokind', '_parent.Classifiers:tc_adapt', '_parent.Classifiers:tc_repr', '_parent.Monitor:monitor', '_parent.Part:_load_stat', '_parent.Part:Stat', '_parent.Prof:pb', '_parent.UniSet:Anything', '_parent.UniSet:idset', '_parent.UniSet:iso', '_parent.UniSet:Nothing', '_parent.UniSet:union', '_parent.UniSet:uniset_from_setcastable', '_parent:View', '_parent.View:_hiding_tag_', '_root:sys', '_root:tracemalloc', '_root.time:ctime', '_root:warnings', ) _doc_Anything = """Anything: Kind A symbolic set that represents all possible Python objects. References [0] heapy_Use.html#heapykinds.Use.Anything""" _doc_Clodo = """Clodo:EquivalenceRelation Clodo(alt:[tc: typeexceptdict+ or dictof = typeoremptytuple+]) -> Kind Equivalence relation by class or dict owner. It distinguishes between objects based on their type just like the Type relation, and in addition distinguishes between dicts depending on what class they are 'owned' by, i.e. occur in __dict__ attribute of. When called it returns the equivalence class defined by the argument, EITHER: tc: A positional argument, a type but not a dict, to create the corresponding equivalence class. OR: dictof: A named argument, to create an equivalence class consisting of all dicts that are owned by objects of the type specified in the argument; or dicts with no owner if an empty tuple is given. XXX express this simpler&better... References [0] heapy_Use.html#heapykinds.Use.Clodo""" _doc_Id = """Id:EquivalenceRelation Id(address: objectaddress+) -> Kind) This equivalence relation defines objects to be equivalent only if they are identical, i.e. have the same address. When called it returns the equivalence class defined by the argument: address: The memory address of an object. References [0] heapy_Use.html#heapykinds.Use.Id""" _doc_Idset = """Id:EquivalenceRelation Idset(node: Anything+) -> IdentitySet This equivalence relation defines objects to be equivalent only if they are identical, i.e. have the same address. When called it returns the equivalence class defined by the argument: node: Anything+ Any object is a valid argument. Note This is mainly for special purpose internal use. The Id equivalence relation is more efficient when partitioning large sets.""" _doc_Module = """Module:EquivalenceRelation x.Module( draw:[name = modulename+ , at = moduleaddress+]) -> Kind This equivalence relation defines objects to be equivalent if they are the same module, or if none of them is a module. Partitioning a set of objects using this equivalence relation will therefore result in one singleton set for each module and one set containing all other objects. Calling the Module equivalence relation creates a Kind containing the module given in the keyword argument(s). Either the name, address or both may be specified. If no argument is specified the equivalence class is that of non-module objects. References [0] heapy_Use.html#heapykinds.Use.Module""" _doc_Nothing = """Nothing: IdentitySet The empty set. References [0] heapy_Use.html#heapykinds.Use.Nothing""" _doc_Prod = """\ Prod: EquivalenceRelation Prod() -> KindOfProdFamily[1] Prod(path_prefix: string+) -> Kind Prod(scope: Anything+) -> Kind Prod(seq: [filename: string+, alt: positive+]) -> KindOfProdFamily[1] In this equivalence relation, objects are classified by the producer, the line in which the object was allocated. In zero-argument form, the equivalence relation creates a Kind matching objects whose producer is unknown. In one-argument form, the equivalence relation constructor creates an alternative equivalence relation and has two possible types of arguments: path_prefix: string+ A path prefix filter on the file name scope: Anything+ Anything that can be used by inspect.getsourcelines() In the two-argument form, the equivalence relation creates a Kind matching objects whose producer matches exactly the given arguments: filename: string+ File name of the producer lineno: positive+ Line number of producer With None arguments, the default equivalence relation will never match, but alternate equivalence relations may, as described in KindOfProdFamily[1]. References [0] heapy_Use.html#heapykinds.Use.Prod [1] heapy_UniSet.html#heapykinds.KindOfProdFamily""" _doc_Rcs = """Rcs: EquivalenceRelation Rcs ( 0..: alt:[kind: Kind+ or sok: SetOfKind+]) -> KindOfRetClaSetFamily (Referrer classification set.) In this equivalence relation, objects are classified by classifying their referrers, using the Clodo equivalence relation. These classifications are collected in a set, representing the classification of the object. Calling Rcs creates an equivalence class from specified set of referrer classifications. The arguments specify a set of Kind objects, each of which representing an equivalence class of Clodo. kind: Kind+ This adds a single Kind to the set of Kinds of referrers. sok: SetOfKind+ This adds each Kind in the sok argument to the total set of Kinds of referrers. References [0] heapy_Use.html#heapykinds.Use.Rcs""" _doc_Size = """\ Size: EquivalenceRelation Size(size: notnegative+) -> KindOfSizeFamily[1]) In this equivalence relation, objects are classified by memory size, so each equivalence class represents a particular size of object. References [0] heapy_Use.html#heapykinds.Use.Size [1] heapy_UniSet.html#heapykinds.KindOfSizeFamily""" _doc_Type = """Type: EquivalenceRelation Type(type: type+) -> KindOfTypeFamily[1] In this equivalence relation, objects are classified by type so each equivalence class represents objects of a particular type. Calling it creates a Kind representing the type specified in the argument: type: type+ A Python type object or a representation of it. References [0] heapy_Use.html#heapykinds.Use.Type [1] heapy_UniSet.html#heapykinds.KindOfTypeFamily""" _doc_Unity = """Unity: EquivalenceRelation Unity() -> Kind[1] In this equivalence relation, all objects are considered equivalent. There is only one equivalence class, that is, Anything[2]. References [0] heapy_Use.html#heapykinds.Use.Unity [1] heapy_UniSet.html#heapykinds.Kind [2] heapy_Use.html#heapykinds.Use.Anything""" _doc_Via = """Via: EquivalenceRelation Via( 0..:rel: relationname+) -> KindOfInViaFamily[1] In this equivalence relation, objects are classified by how they are referred from their referrers, so each equivalence class represents objects that have a particular set of relations to their referrers. Calling it creates a Kind representing the set of referrers specified by the argument: rel: relationname+ Each argument specifies one referrer relation. The arguments should be strings and can be of any of the following forms. [expression] Indexing of a dict, list, tuple (etc). The expression must be a Python expression that can be evaluated in a local environment. The environment will contain the builtins and a name 'hp' that is bound to the current Use instance. .attribute Getting an attribute from a builtin type or a slot of a slotted type. (I.E. not an attribute that is in a dict of an object.) .f_locals["name"] A local variable of a frame. .f_locals ["name"] A variable in a CELL of a frame. Note the space between f_locals and [. This is to distinguish it from ordinary locals, and still use a syntax that could be used to access those variables directly from Python. .keys()[integer] A key in a dictionary, at the indicated place in its keys(). References [0] heapy_Use.html#heapykinds.Use.Via [1] heapy_UniSet.html#heapykinds.KindOfInViaFamily""" _doc_findex = """ findex( 0..:kind: Kind+) -> ( Subkind of: EquivalenceRelation[1] callable: (index: notnegative+) Calling the returned equivalence relation creates an equivalence class. Argument index: notnegative+ The position of the matching kind in the sequence of kinds. The first one has index 0. Specifying the length of the sequence means that the equivalence class returned is the one where none of the kinds in the sequence matched. ) Create an equivalence relation based on a sequence of kinds. The name is a combination of find and index. The classification of each objects is done as follows: For each kind in the sequence, check whether the object is an element of that kind. If it is, the classification is the index of that kind in the sequence. If the end of the sequence is reached, the classification is the length of the sequence. Argument kind: Kind+ Each argument specifies the kind in that position in the sequence. Bugs Though the Kind objects representing the equivalence classes work with set operations such as intersection and union, the tests such as subset and equality do not generally give the expected result. References [0] heapy_Use.html#heapykinds.Use.findex [1] heapy_UniSet.html#heapykinds.EquivalenceRelation""" _doc_idset = """idset(nodes: iterable+) -> IdentitySet[1] Create a set of objects based on identity. Argument nodes: iterable+ The argument must be an iterable and may yield any kind of objects. Note This method is the same as iso except for the argument. References [0] heapy_Use.html#heapykinds.Use.idset [1] heapy_UniSet.html#heapykinds.IdentitySet""" _doc_iso = """iso( 0..:node: Any+) -> IdentitySet[1] Create a set of objects based on identity. Argument node: Any+ Any kind of objects are valid arguments. Note This method is the same as idset[2] except for the argument. References [0] heapy_Use.html#heapykinds.Use.iso [1] heapy_UniSet.html#heapykinds.IdentitySet [2] heapy_Use.html#heapykinds.Use.idset""" _doc_sokind = """ """	23.05 KB	2026-01-20 12:58
📄 View.py class Horizon: def __init__(self, mod): self.mod = mod self._hiding_tag_ = mod._hiding_tag_ # Make preallocations of things that will be needed for news() self.retset = self.mod.retset self.hv = mod.hv self.exc_info = self.mod._root.sys.exc_info self.iso = self.mod.iso str(self.retset(self.iso(1, [], (), {}, self.__dict__)) - self.iso(())) mod.hv.heap mod.enter mod.gc.collect() self.hv_horizon = mod.heapyc.Horizon(self.hv) def news(self): r = self.retset(self.hv_horizon.news(self.mod.enter(self.hv.heap))) return r class ClearCallback(object): __slots__ = 'callback', def __init__(self, callback): self.callback = callback def __call__(self, wr): if self.callback is not None: self.callback(wr) else: print('No callback') class Gchook_type(object): __slots__ = 'x', '__weakref__', 'cb' def __init__(g): g.x = g class ObservationList(list): __slots__ = '_hiding_tag_', def __init__(self, iterable, hiding_tag): list.__init__(self, iterable) self._hiding_tag_ = hiding_tag class _GLUECLAMP_: _imports_ = ( '_parent.ImpSet:immnodeset', '_parent.ImpSet:immnodeset_union', '_parent.ImpSet:mutnodeset', '_parent.ImpSet:NodeSet', '_parent.UniSet:nodeset_adapt', '_parent.UniSet:retset', '_parent.Use:idset', '_parent.Use:iso', '_parent.Use:Type', '_root:ctypes', '_root:gc', '_root:types', ) _chgable_ = ('is_rg_update_all', 'referrers_lock', '_is_clear_drg_enabled', 'root',) _setable_ = ('_hiding_tag_', 'target', 'is_hiding_calling_interpreter',) is_hiding_calling_interpreter = False is_rg_update_all = False _is_clear_drg_enabled = 1 # Flag mainly for test, Note Apr 19 2005 _hiding_tag_ = [] #opt_rg_update_all = True _uniset_exports = ( # 'dominos', # 'domisize', 'imdom', # 'indisize', # 'referents', # 'referrers', 'referrers_gc', ) def _get__clear_hook(self): return self.mutnodeset() def clear_check(self): ch = self._clear_hook try: wr = list(ch)[0] except IndexError: self.clear_setup() else: # When tracing is enabled, each local variable gets two references. # See Guppy 3 issue #3. c = [wr()] if c[0] is None: self.clear_setup() elif self._root.sys.getrefcount(c[0]) > 3: print('GC hook object was referred to from somebody!') self.clear_callback(wr) c[0].cb.callback = None def clear_callback(self, wr): self._clear_hook.clear() for m in self.clear_methods: m() self.clear_setup() def clear_setup(self): ch = self._clear_hook ch.clear() c = self.gchook_type() cb = self.ClearCallback(self.clear_callback) c.cb = cb ch.add(self._root.weakref.ref(c, cb)) def _get_clear_methods(self): return [] def clear_register_method(self, m): self.clear_methods.append(m) self.clear_check() def _get_dict_ownership(self): drg = self.nodegraph() def clear_drg(): if drg.is_sorted and self._is_clear_drg_enabled: drg.clear() else: pass self.clear_register_method(clear_drg) return drg def _get_gchook_type(self): return Gchook_type def _get_capsule_type(self): return self.ctypes.cast( self.ctypes.pythonapi.PyCapsule_Type, self.ctypes.py_object).value def _get_heapdef_modules(self): # We touch self.heapyc to import it & its dependent guppy.sets; # this is kinda specialcase-hacky but see Notes Apr 8 2005. self.heapyc return list(self.target.sys.modules.items()) def _get_heapdefs(self): heapdefs = [] for n, m in self.heapdef_modules: try: hd = getattr(m, '_NyHeapDefs_') except AttributeError: continue if not hd or not isinstance(hd, self.capsule_type): continue heapdefs.append(hd) return tuple(heapdefs) def _get_heapyc(self): return self._parent.heapyc def _get_hv(self): hv = self.new_hv(_hiding_tag_=self._hiding_tag_, is_hiding_calling_interpreter=self.is_hiding_calling_interpreter) return hv def _get_norefer(self): return self.mutnodeset() def _get_referrers_targets(self): return [] def _get_rg(self): rg = self.nodegraph() self.clear_register_method(self._clear_rg) return rg def _clear_rg(self): if self.referrers_lock: return rg = self.rg if rg.is_sorted: rg.clear() self.norefer.clear() else: pass def _get_referrers_lock(self): return 0 def _get_root(self): return self.heapyc.RootState def _get_target(self): return self._parent.Target.Target(self._hiding_tag_) def _set_root(self, root): self.clear_retainers() self.hv.root = root def call_with_referrers(self, X, f): self.referrers_lock += 1 try: self.update_referrers(X) return f(X) finally: self.referrers_lock -= 1 def clear_retainers(self): """G.clear_retainers() Clear the retainer graph V.rg. """ self.rg.clear() self.norefer.clear() def dominos(self, X): """dominos(X) -> idset Return the dominos of a set of objects X. The dominos of X is the set of objects that are dominated by X, which is the objects that will become deallocated, directly or indirectly, when the objects in X are deallocated.""" return self.dominos_tuple((X,))[0] def dominos_tuple(self, X): """V.dominos_tuple(X) -> tuple of idsets Return a tuple of dominos for the tuple of sets of objects X.""" D_ = [self.nodeset_adapt(x) for x in X] # Convert to naming like in the appendix T = self.hv.reachable S = self.immnodeset([self.root]) D = self.immnodeset_union(D_) W = T(S, D) return tuple([self.retset(T(Di, W) - T(D, W \| Di)) for Di in D_]) def domisize(self, X): """domisize(X) -> int Return the dominated size of a set of objects X. The dominated size of X is the total size of memory that will become deallocated, directly or indirectly, when the objects in X are deallocated. See also: indisize.""" return self.domisize_tuple((X,))[0] def domisize_tuple(self, X): """"V.domisize_tuple(X) -> tuple of ints Return a tuple of dominated sizes for the tuple of sets of objects X.""" return tuple([self.indisize(dominos_i) for dominos_i in self.dominos_tuple(X)]) def enter(self, func): if self.hv.is_hiding_calling_interpreter: self.hv.limitframe = None elif self.hv.limitframe is not None: return func() else: import inspect self.hv.limitframe = inspect.currentframe().f_back.f_back try: retval = func() finally: self.hv.limitframe = None return retval def gchook(self, func): c = self.gchook_type() ho = self.mutnodeset() def cb(wr): func() ho.clear() c = self.gchook_type() ho.add(self._root.weakref.ref(c, cb)) ho.add(self._root.weakref.ref(c, cb)) return self.mutnodeset([ho]) def heapg(self, rma=1): # Almost the same as gc.get_objects(), # except: # 1. calls gc.collect() first (twice) # 2. removes objects of type gchook # 3. removes objects of type ClearCallback # 4. removes all objects of type types.FrameType # 5. removes all objects of weakref type # 6. If rma = 1, # removes all that is in the reachable heap # except what is in the set itself. # . wraps the result in an IdSet self.gc.collect() self.gc.collect() objs = self.gc.get_objects() cli = self.hv.cli_type() objs = cli.select(objs, self.gchook_type, '!=') objs = cli.select(objs, ClearCallback, '!=') objs = cli.select(objs, self._root.types.FrameType, '!=') objs = cli.select(objs, self._root.weakref.ReferenceType, '!=') r = self.retset(objs) del cli, objs if rma: r = (r - self.idset(self.heapyc.HeapView( self.heapyc.RootState, self.heapdefs ).reachable_x( self.immnodeset([self.heapyc.RootState]), self.observation_containers() )) ) return r def heapu(self, rma=1): self.gc.collect() self.gc.collect() r = self.gc.get_objects() exclude = (self.Type(self.gchook_type) \| self.Type(ClearCallback) ) if rma: exclude \|= self.idset(self.heapyc.HeapView( self.heapyc.RootState, self.heapdefs ).reachable_x( self.immnodeset([self.heapyc.RootState]), self.immnodeset([r]) )) r = self.retset(r) - exclude ref = r.referents - exclude while not ref <= r: r \|= ref ref = ref.referents - exclude del ref, exclude r = r.bytype # Avoid memoizing for complicated classification return r def heap(self): """V.heap() -> idset Return the set of objects in the visible heap. """ global heap_one_time_initialized # This is to make sure that the first time called # the heap will contain things that may likely be loaded later # because of common operations. if not heap_one_time_initialized: old_root = self.root objs = [[], 'a', 1, 1.23, {'a': 'b'}, self] self.root = objs try: repr(self.idset(objs)) repr(self.iso(objs[0]).shpaths) repr(self.iso(objs[0]).rp) finally: self.root = old_root del objs del old_root heap_one_time_initialized = True self.gc.collect() # Sealing a leak at particular usage ; Notes Apr 13 2005 # Exclude current frame by encapsulting in enter(). Note Apr 20 2005 return self.enter(lambda: self.idset(self.hv.heap())) def horizon(self): return self.Horizon(self) def imdom(self, X): """imdom(X) -> idset Return the immediate dominators of a set of objects X. The immediate dominators is a subset of the referrers. It includes only those referrers that are reachable directly, avoiding any other referrer.""" pred = self.nodeset_adapt(self.referrers(X)) visit = self.hv.reachable_x(self.immnodeset([self.root]), pred) return self.retset(pred & visit) def indisize(self, X): """indisize(X) -> int Return the sum of the individual sizes of the set of objects X. The individual size of an object is the size of memory that is allocated directly in the object, not including any externally visible subobjects. See also: domisize.""" return self.hv.indisize_sum(self.nodeset_adapt(X)) def new_hv(self, _hiding_tag_=None, is_hiding_calling_interpreter=False, heapdefs=None, root=None, gchook_type=None): if heapdefs is None: heapdefs = self.heapdefs if root is None: root = self.root if gchook_type is None: gchook_type = self.gchook_type hv = self.heapyc.HeapView(root, heapdefs) hv._hiding_tag_ = _hiding_tag_ hv.is_hiding_calling_interpreter = is_hiding_calling_interpreter hv.register_hidden_exact_type(gchook_type) # hv.register__hiding_tag__type(self._parent.UniSet.UniSet) hv.register__hiding_tag__type(self._parent.UniSet.Kind) hv.register__hiding_tag__type(self._parent.UniSet.IdentitySetMulti) hv.register__hiding_tag__type(self._parent.UniSet.IdentitySetSingleton) return hv def nodegraph(self, iterable=None, is_mapping=False): ng = self.heapyc.NodeGraph(iterable, is_mapping) ng._hiding_tag_ = self._hiding_tag_ return ng def obj_at(self, addr): try: return self.immnodeset(self.hv.static_types).obj_at(addr) except ValueError: pass try: return self.immnodeset(self.gc.get_objects()).obj_at(addr) except ValueError: pass try: return self.immnodeset(self.hv.heap()).obj_at(addr) except ValueError: raise ValueError('No object found at address %s' % hex(addr)) def observation_containers(self): # Return the current set of 'observation containers' # as discussed in Notes Oct 27 2005. # returns a nodeset, not an idset, to avoid recursive referenes objs = self.gc.get_objects() cli = self.hv.cli_type() objs = (cli.select(objs, self.NodeSet, '<=') + cli.select(objs, ObservationList, '<=') + cli.select( objs, self._parent.UniSet.IdentitySetSingleton, '<=') ) r = self.immnodeset([x for x in objs if getattr( x, '_hiding_tag_', None) is self._hiding_tag_]) del cli, objs return r def observation_list(self, iterable=()): # Return an ObservationList object with our _hiding_tag_ return ObservationList(iterable, self._hiding_tag_) def referents(self, X): """V.referents(X) -> idset Return the set of objects that are directly referred to by any of the objects in the set X.""" return self.retset(self.hv.relimg(self.nodeset_adapt(X))) def referrers(self, X): """V.referrers(X) -> idset Return the set of objects that directly refer to any of the objects in the set X.""" X = self.nodeset_adapt(X) if self.is_rg_update_all and self.root is self.heapyc.RootState: if not (self.rg.domain_covers(X) or self.rg.domain_covers(X - self.norefer)): self.rg.clear() import gc gc.collect() self.hv.update_referrers_completely(self.rg) addnoref = X - self.rg.get_domain() self.norefer \|= addnoref else: Y = self.mutnodeset(X) Y -= self.norefer if not self.rg.domain_covers(Y): for wt in self.referrers_targets: t = wt() if t is not None: Y \|= t.set.nodes Y \|= self.rg.get_domain() self.rg.clear() self.hv.update_referrers(self.rg, Y) self.norefer.clear() self.norefer \|= (X \| Y \| self.rg.get_range()) self.norefer -= self.rg.get_domain() Y = self.mutnodeset(X) - self.norefer if not self.rg.domain_covers(Y): print('update_referrers failed') print('Y - domain of rg:') print(self.idset(Y - self.rg.get_domain())) Y = None X = self.rg.relimg(X) X = self.immnodeset(X) - [None] X = self.retset(X) return X def referrers_gc(self, X): """V.referrers_gc(X) -> idset Return the set of objects that directly refer to any of the objects in the set X. This differs from referrers in that it uses the gc module's view of the referrers. This is more or less valid depending on viewpoint. """ X = tuple(self.nodeset_adapt(X)) return self.idset(self.gc.get_referrers(*X)) - self.iso(X) def referrers_add_target(self, t): def remove(wr): self.referrers_targets.remove(wr) wr = self._root.weakref.ref(t, remove) self.referrers_targets.append(wr) def update_referrers(self, X): """V.update_referrers(X) Update the view V from the set X. X must be adaptable to NodeSet. V.rg is updated so that in addition to its previos mapping, it will also contain mappings for the elements of X to their referrers, from them to their referrers and so on. """ self.referrers(X) def prime_builtin_types(): # Make sure builtin types have been completely allocated # with all method descriptors etc. # so subsequent events will not give spurios confusing allocations. # This should need to be done only once. # (Or whenever a new (extension) module is imported??) # The problem & solution is further discussed in Notes Nov 9 2005. import types import guppy.heapy.heapyc import guppy.sets.setsc import os import sys import warnings import weakref for mod in list(sys.modules.values()): if mod is None or getattr(mod, '__dict__', None) is None: continue for t in list(mod.__dict__.values()): if isinstance(t, type): dir(t) # Other type(s) for t in [type(iter([])), type(iter(())), ]: dir(t) # Ubuntu apport package installs a sys.excepthook that will import a lot # of packages when there is an unhandled exception. This can cause a lot # of irrelevant stuffs when we analyze a relative heap. try: import apport.fileutils except ImportError: pass else: import re import traceback if 'pythoncom' in sys.modules: def get_pywin32_ver(): try: import pkg_resources return pkg_resources.get_distribution('pywin32').version except Exception: pass try: import distutils.sysconfig site_pkg = distutils.sysconfig.get_python_lib(plat_specific=1) with open(os.path.join(site_pkg, 'pywin32.version.txt')) as f: return f.read().strip() except Exception: pass return None pywin32_ver = get_pywin32_ver() if pywin32_ver: try: pywin32_ver = int(pywin32_ver) except ValueError: pass else: if pywin32_ver < 300: warnings.warn( 'pythoncom in pywin32 < 300 may cause crashes. See ' 'https://github.com/zhuyifei1999/guppy3/issues/25. ' 'You may want to upgrade to the newest version of ' 'pywin32 by running "pip install pywin32 --upgrade"') prime_builtin_types() # The following global variable is used by heap() # to do extra initializations the first time it is called. # having to do that we want to do import and init things # but only if heap is actually called heap_one_time_initialized = False	19.05 KB	2026-01-20 12:58
📄 __init__.py class _GLUECLAMP_: uniset_imports = ('UniSet', 'View', 'Path', 'RefPat') def _get_fa(self): us = self.UniSet us.out_reach_module_names = self.uniset_imports return us.fromargs	209 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 heapyc.cpython-311-x86_64-linux-gnu.so ELF��>��h��@��0c��@�8� �@��^��^��`��`��`��@��@��@��x��x��PU��W��x��x��x��8��8��8��$��$��P�td��8��8��8��Q�td��R�td��GNU��=S7E1�O�<��T��Y��C�� "��@bA (�0� D�Hh�BBF�@��90R��d��f�_��&��sz�T��z ^��{�8�Q�Yx?��ʆ%�1nh�"�U)�.��8��(��'��F�B�REo�mR�}� ��ͦ�.Y@1݇��Y��C�=Z-C�7r��q��<Zsufl�i��̓ƚ�P̏��=uS�>�KI_�e<�`0��>z�G�S�9T�¼g�ĸ/+$��sд�� JPh�OpW�\|�TF ��kVC8�%�"GO��C�m��9�dy�j!�2��7��5��5��[ ��?��K�� [��s��z ��t��%��a ��\|��%�� 7��H��`��'��i �� [��u��X�� ;��r�� X��H��e��U�� C��c�� 2 ��h��E��?��o��d��K ��Z��N�� i�� n��2�� q��P ��"��s ��S��$��: ��2�� L��"��/ ��# ���� /�� px��p�� $��0$��u��f��0��e��w��P �� J��p<��{��@�� K��!��`�� P��l��P ��Y��0��7��=�� S��!�� O ��@�� =��y ��p!��n��@��8�� !�� `��z��m �� 0�� X�� /�� J�� 4�� 0 �� p��@ ��`��-�� j��0�� @ ��Z��@�� %�� 1�� _ �� E��@��:��0�� ]��p��v��m��A�� @��X��!�� )�� P��Q�� Y��P�� __gmon_start__�_fini�_ITM_deregisterTMCloneTable�_ITM_registerTMCloneTable�__cxa_finalize�PyTuple_Type�_Py_NoneStruct�_Ny_RootStateStruct�_Py_Dealloc�PyList_Append�PyList_New�PyExc_SystemError�PyErr_SetString�PyErr_Occurred�ng_as_flat_list�PyDict_GetItem�PyObject_SetItem�PyObject_GC_UnTrack�PyObject_GC_Del�_PyTrash_cond�PyThreadState_Get�_PyTrash_begin�_PyTrash_end�PyUnicode_FromString�PyObject_IS_GC�PyTuple_New�PyExc_RuntimeError�PyObject_CallFunctionObjArgs�PyObject_RichCompareBool�PyDict_SetItem�NyNodeTuple_Type�_PyObject_GC_NewVar�memset�PyObject_GC_Track�PyExc_ValueError�PyExc_TypeError�PyLong_AsSsize_t�PyDict_Next�_Py_FatalErrorFunc�qsort�PyMem_Realloc�PyUnicode_FromFormat�rootstate_traverse�PyInterpreterState_Head�PyInterpreterState_Get�PyInterpreterState_Next�PyThreadState_GetFrame�PyFrame_GetBack�PyFrame_Type�abort�PyObject_Hash�PyErr_CheckSignals�ng_iter�NyNodeGraphIter_Type�_PyObject_GC_New�stderr�fwrite�fprintf�PyType_IsSubtype�_Py_NotImplementedStruct�_Py_FalseStruct�_Py_TrueStruct�_PySys_GetSizeOf�PyErr_ExceptionMatches�PyErr_Clear�PyTuple_GetItem�PySequence_Check�PySequence_Size�PySequence_GetSlice�NyRelation_Type�PyObject_RichCompare�_PyWeakref_RefType�PyMem_Free�PyErr_Format�_PyWeakref_ProxyType�_PyWeakref_CallableProxyType�PyMem_Malloc�PyWeakref_NewRef�PyErr_NoMemory�_PyObject_GetDictPtr�dict_relate_kv�_PyTraceMalloc_GetTraceback�PySequence_GetItem�PyUnicode_AsUTF8�sscanf�PyExc_AttributeError�PyExc_DeprecationWarning�PyErr_WarnFormat�strcmp�PyMember_GetOne�NyMutNodeSet_New�nodeset_exports�NyMutNodeSet_NewHiding�NyMutNodeSet_NewFlags�NyNodeSet_setobj�PyLong_FromSsize_t�PyDict_New�NyNodeSet_clrobj�NyNodeSet_hasobj�NyNodeSet_iterate�PyList_Size�NyNodeSet_NewImmCopy�NyImmNodeSet_NewSingleton�NyNodeSet_be_immutable�gc_get_objects�PyImport_ImportModule�_PyObject_CallMethod_SizeT�xt_free_table�xt_findout_size�xt_findout_traverse�xt_findout_relate�PyType_Type�_PyArg_ParseTupleAndKeywords_SizeT�_PyArg_ParseTuple_SizeT�PyType_Ready�PyList_AsTuple�PyTuple_SetItem�hv_mutnodeset_new�NyNodeGraph_Type�PyList_GetItem�PyList_SetSlice�PyExc_IndexError�hv_is_obj_hidden�NyRootState_Type�_hiding_tag__name�NyHeapView_SubTypeNew�PyObject_GetAttrString�NyStdTypes_HeapDef�NyHvTypes_HeapDef�PyTuple_Size�PyCapsule_Type�PyCapsule_GetName�strrchr�PyCapsule_GetPointer�NyRelation_SubTypeNew�NyRelation_New�NyHeapView_iterate�PyObject_Size�NyHeapView_Type�PyObject_GetIter�PyIter_Next�horizon_new�NyObjectClassifier_Compare�PyLong_AsLong�cli_cmp_as_int�NyObjectClassifier_New�NyObjectClassifier_Type�PyDict_Type�PySys_GetObject�PyExc_UserWarning�PyLong_FromLong�NyNodeGraph_Clear�hv_update_referrers_completely�ng_clear_method�NyNodeGraph_AddEdge�PySequence_List�hv_update_dictowners�hv_update_referrers�PyBaseObject_Type�_PyObject_New�PyList_SetItem�ng_add_edge�ng_add_edges_n1�NyNodeGraph_SubtypeNew�NyNodeGraph_SiblingNew�NyNodeGraph_Invert�NyNodeGraph_Region�PyExc_NotImplementedError�PyExc_KeyError�PyErr_SetObject�NyNodeGraph_Update�PyObject_IsTrue�NyNodeGraph_Copy�ng_copy�NyNodeGraph_Inverted�NyNodeGraph_New�NyNodeGraph_init�PyInit_heapyc�NyHorizon_Type�PyModule_Create2�PyModule_GetDict�PyDict_SetItemString�NyStdTypes_init�dlsym�PyType_GenericNew�PyCapsule_Import�PyExc_ImportError�heapyc_doc�rootstate_doc�PyObject_GenericGetAttr�PyObject_SelfIter�horizon_doc�cli_doc�dummy�PyType_GenericAlloc�PyObject_Free�NyNodeSet_Type�PyList_Type�PySet_Type�PyFrozenSet_Type�PyFunction_Type�PyModule_Type�PyTraceBack_Type�PyCell_Type�PyCFunction_Type�PyCode_Type�PyDictProxy_New�libpthread.so.0�libc.so.6�GLIBC_2.2.5�� ui �� Pi��i�� @��W��H��(Z��P��+Z��X��.Z��`��1Z��h��3Z��X��"Y��X��0��X��8��X��`��X��h��Y��p��Y��x��Y��'Y��-Y��'Y��-Y��Z��Z��XT��fT�� 3Y��(��6V��0��5Y��8��7Y��@��BY��P��KY��X��PY��`Y��@��jY��{��hI��4U��(��ZU��P��eU��x��qU��~U��tU��T��U��@��U��h��U��U��jT��yT��0��T��X��t��T��T��T��T�� T��H��T��p��T��T��T��U��(U��`��h�� p��kV��I��X��8J��rY��J�� Z��(��`��8��`��Z��Y��`k��`��V��`��Z��!��`�� W��(��8��`��`��6Z��h�� k��p��`��x��_��kV��L��AZ��xN��KY��0��@P��8��_Z��X��Q��Z��R��j��0��}Z��[��j��j��(��Z��0��[��8��P��@��Pr��h��B[��p��M[��x��@��"Y��X��(��W��0��R��8��@��@s��H��@��h��Z��p��S��x��@��r��0��B[��M[�� f[��(S��r��(��sZ��0��PS��8��P��H��r��h��lZ��p��S��x��j��j��W��M[��p��`j��W��S��P�� s��( ��`i��0 ��i��8 ��i�� YY�� ` ��\|Y��x �� Y�� @�� Y�� Y�� T�� `��Y��@�� Y��(��p��8��`��@��Y��H�� X��`��Y��h��x��Y�� `��Y��!��Y��@��Y�� Y��!�� X��Z��p��o��k�� q�� W�� @�� v��W��`�� s�� W��(��8�� n��@��lZ��H��X��r��`��sZ��h��x��q��W�� W��0��l��}Z�� l��IW�� p��>W��0��`n�� Z��(�� 8��k��@��Z��H��@��X��l��`��V��h��x��w��Z��j��Z��j��bV��i��V�� h��Z��0��h�� Z��(��8��e��@��Z��H��X��f��`��{V��h��x��d��Y��c��V��0��`��X��^��X��]��Z��\��P��pq��X��Pl��`��w��X��r[��i��`v��Pj��[��p��X��l��j��l��0��#��`��S��h��`q��p��8��l��h��l��8��[��P��`��k��` ��`#��X��P��[��0u�� x��[��`��@x�� p��H�� P��X��`�� T��0��p��@k��l��`��@5��P<��4��@��`4��07��07��9��@��09��x��2��@/��6�� @6��@ ��5��x ��(�� ,�� )�� ��!��8��H��P��X�� `��h��p��x��X ��H��#��&��(��)����/��0��4��A��D��E��I�� (��0��U��8��_��@��`��H��c��P��d��X��f��`��h��h��i��p��j��x��p��s��v��~�� h �� G��G��p��G��G��P��G��G��G�� !�� `��@��X��X��P��X��X��X��0��X��0��5��5��p�� (��0��8��@��H��P��X�� `��h�� p��x�� (�� 0��8��"��@��$��H��%��P��'��X��+��`��,��h��-��p��.��x��1��2��3��6��7��8��9��:��;��<��=��>��?��@��B��C�� E��(��F��0��H��8��@��J��H��P��K��X��L��`��M��h��N��p��O��x��P��Q��R��S��T��V��W��Y��Z��[��\��]��^�� a��(��b��0��e��8��g��@��k��H��l��P��m��X��`��n��h��o��p��q��x��r��t��u��w��x��y��z��{��\|��}�� (��0��8��H��H��n�H��t�+��H��5�o��%�o�@��%�o�h��%�o�h��%�o�h��%�o�h��%�o�h��%�o�h��%�o�h��%�o�h��p��%�o�h��`��%�o�h ��P��%�o�h ��@��%�o�h��0��%�o�h�� %zo�h ��%ro�h��%jo�h��%bo�h��%Zo�h��%Ro�h��%Jo�h��%Bo�h��%:o�h��%2o�h��%o�h��p��%"o�h��`��%o�h��P��%o�h��@��% o�h��0��%o�h�� %�n�h��%�n�h��%�n�h��%�n�h ��%�n�h!��%�n�h"��%�n�h#��%�n�h$��%�n�h%��%�n�h&��%�n�h'��p��%�n�h(��`��%�n�h)��P��%�n�h��@��%�n�h+��0��%�n�h,�� %zn�h-��%rn�h.��%jn�h/��%bn�h0��%Zn�h1��%Rn�h2��%Jn�h3��%Bn�h4��%:n�h5��%2n�h6��%n�h7��p��%"n�h8��`��%n�h9��P��%n�h:��@��% n�h;��0��%n�h<�� %�m�h=��%�m�h>��%�m�h?��%�m�h@��%�m�hA��%�m�hB��%�m�hC��%�m�hD��%�m�hE��%�m�hF��%�m�hG��p��%�m�hH��`��%�m�hI��P��%�m�hJ��@��%�m�hK��0��%�m�hL�� %zm�hM��%rm�hN��%jm�hO��%bm�hP��%Zm�hQ��%Rm�hR��%Jm�hS��%Bm�hT��%:m�hU��%2m�hV��%m�hW��p��%"m�hX��`��%m�hY��P��%m�hZ��@��% m�h[��0��%m�h\�� %�l�h]��%�l�h^��%�l�h_��%�l�h`��%�l�ha��%�l�hb��%�l�hc��%�l�hd��%�l�he��%�l�hf��%�l�hg��p��%�l�hh��`��%�l�hi��P��%�l�hj��@��%�l�hk��0��%�l�hl�� %zl�hm��%rl�hn��%jl�ho��%bl�hp��%Zl�hq��%Rl�hr��%Jl�hs��%Bl�ht��%:l�hu��%2l�hv��%l�hw��p��%"l�hx��`��%l�hy��P��%l�hz��@��% l�h{��0��%l�h\|�� %�k�h}��%�k�h~��%�k�h��%�k�h��%�k�h��%�k�h��%�k�h��%�k�h��P���1��],��1��0��f.��f�H�=��H��H9�tH��e�H��t ��H�=��H�5��H)�H��H��?H��H�H�tH��f�H��t��fD��=I��u/UH�=�f��H��tH�=�b��h��!��]��{��f.��H��I��H��I�@P�` ��f.��f.��1��ff.��f�H��H��H��H�G��ff.��f�H�G@L�GXH�@ J9t�g8�1��D��H�OH��H��x31Ҹ�eC�@�Hi�CB�H3D�H��H9�u�H1�H��t�f��eC�H1�H��u�H��f.��H�d��H�W(H�BH�@ H��tH�z��f��H�H��H�H��1�H9��H�H��H��H��t ��1��D��H�Yd�H��@��f.��H�FH��H9~t 1��H�F1��H�GH��tH��f�H��c�H��@�H�H��H��H��t ��1��D��H�GL�GH�@L��ff.��@�H�H��H��H��t ��1��D��AVI��AUATI��UH��SH� �~H1��!@�H�EL��J�\|(A�ԅ�u#H��H9] ~#H�EI��L��I��J�<(A�ԅ�t�[]A\A]A^ÐH�}H��t[L��]L��A\A]A^��[1�]A\A]A^�D��H��H9r��ff.��L�GI�@H9G(t"I�@H�WH�w L��H��f.��1��ff.��f�1��ff.��f�H�)c�H��@�SH��H�H��tH�/t H�C��1�[Ð��H�C��1�[�ff.��@�SH��H�H��tH�/t H�C��1�[Ð�k�H�C��1�[�ff.��@�ATI��UH��S��B(��H��tx�� w[H��I�<�H��t6H��A�D$(H�m�tA�D$([]A\��H��fD��I��H��H��u��D��H��`�H�5J��H�8��H��uH�-_a�H�E��m��ff.��AUATUH��1�SH��L�H��tZH�} �I��~S1��)f��H�EL��J�t ��t&H��H9] ~&H�EI��L��I��J�4 ��u�I�m�tE1�H��L��[]A\A]�@�L��E1��H��L��[]A\A]�ff.��@�AUI��ATUSH��H��H�L��H�xH�@�PH��H�{H��H��I��H��tOL��L��tgH�m�A��tH��D��[]A\A]�@�H��h�H��D��[]A\A]�f.��1��I��H��t H�{H��H��u-D��I�,$tQH�m�t:A��H��D��[]A\A]�fD��I�,$�V��L��I��H��A��L��fD��UH��H�}H��tH�/tH��]��H��]��f.��ATUH��H��Q��H�5��H��u&H�}H��tH�/u�J�H��H��]A\�{��H��H��I��u+H�}H��tH�/t!H��J�M��tH��L��]A\�v��X]A\��f.��ATUH��H��H�5��H��u^H�}H��t5H�/A��u)��H�EH��@��M��tbH��L��]A\��H�EH��H��@��H��]A\��f��;�H��H��I��uH�}H��t�H�/u��H��]A\��H�=��T��@�ATH�GL�g(I��L` �i��A��I�D$E��LE�L��A\�@�H�GH�@ H9G��SH��H��tgH�SH�K H9J u=�z1�t7H�KH��H��H��HrH��H�6H�RH�H�pH�H�P H�K[�@�H�(tH�{\�H�5��H�8�D�1�[�H��H��fD��1��ff.��f�H�0H��\�H��H9�tH9�t1�1��H��H��H�ֺ�� ATUH��SH� H��I��H��tI�$L��[]A\��H��u�H�} H��H��t�I��ff.��f�ATUH��SH� H��I��H��tI�$L��[]A\��H�} H��H��t�I��ATUH��SH� H��m�I��H��tI�$L��[]A\��+�H��u�H�} H��H��W��t�I��ff.��f�AWAVAUATUSH��H�F��)��H�GL�vI��I��L9p��H�=rZ�L��I��H��H�x1�J��L��3�M��~_1��-f.��H��H�z��H��H��I�l�H��L9�t.I�GI�l�H�T�H�BH�@ H��u�H�E�I�l�H��L9�u�I� L��C�H��H��t}H�E�I�,$tGH��H��[]A\A]A^A_�D��H�Z�H�5��1�H�8��fD��I�,$t 1��D��L��fD��H��Y�H�5b��1�H�8�p��H��z��I� L��L��b��L��U��AUATUH��SH��(H�L��H9��H��H��H�@H9�u�H��H�EH�H�=��t6H�}H��tH�/tH�EH��H��@��H��([]A\A]��D��ڐH�=��H��t�H�D$��L�l$L�d$H�\$�$f.��H�\|$��H�T$H�=��H�B0L��L��H��X��u�H�=��H�/tH�t��Q��R��H�Y��-��H�5��H�=>��AVH�'��H� ��AUATUH��S�2�HD�H�w H��}2�t7H�] H��H��1�H9��H�]([H�E�E1]A\A]A^�fD��H�u H��H��~�H�}H��L�,7H�_L�g I9�w+��D��I�D$�H9�t �AoD$�H��I��M9�vOI�\|$�M��H;{�u�M�D$�L;C�u�H�/tHI�(u�L��B��H�}H��H�] �O��f.��H+]H��H�] H��@��M�D$��@�H�E ��f��AWAVAUATUSH��H�oH�} ��I��1�L�-��D��H9BtZH��H9] ~{H�UI��I�FI��L�H;u�H��L��1�M�~ �(�L��H��A�ׅ�uAH�UI�FL�H9Bu�D��H��H�="��1�M�f ��L��H��A�ԅ��{��H��1�[]A\A]A^A_�@�AWAVAUATUSH��L�g L�H�o��I��9�H��tI��A�8�tM9nt �_�I9�tL��I��H��u�1�H��[]A\A]A^A_�f��I��x��H��t H��A�ԅ�u�I��H��t H��A�ԅ�u�I��H��t H��A�ԅ�u�I��H��t H��A�ԅ�u�I��H��tH��A�ԅ��v��I��H��tH��A�ԅ��\��I��H��tH��A�ԅ��B��I��x��H��tH��A�ԅ��(��I��H��tH��A�ԅ��I��H��tH��A�ԅ��I�� H��tH��A�ԅ��I�� H��tH��A�ԅ��I�� H��tH��A�ԅ��I�� H��tH��A�ԅ��I�]H��,��h��f�H��G��H�{PH��tH��A�ԅ��X��H�{XH��tH��A�ԅ��A��H�{`H��tH��A�ԅ����H�{hH��tH��A�ԅ��H�{pH��tH��A�ԅ��H��@��H��tH��A�ԅ��H��H��tH��A�ԅ��H��H��tH��A�ԅ��H��H��tH��A�ԅ��H��H��tH��A�ԅ��z��H��H��tH��A�ԅ��`��H�[H��A��I�L9��H��tH��A�ԅ��.��fD��H��H��H��H�D$H��A��H�\|$��H�/��y��AW1�AVAUATUSH��(�[�H��I��H��H�� 1�@��s��H��H��u��H�D$H��tL�= ��H9D$tLH�\|$��7�H�D$H��u�H��(L��[]A\A]A^A_��H��I�� I�,$��E1��H��H�=��1��H��H��t%H��L��.��H�E��H��H�E��H��H�=��1��=�H��H��t%H��L��H�E��^��H��H�E��H�c��H�=B��1��H��H��t%H��L��H�E��H��H�E��L��H� ��H�=��1��H��H��t%H��L��b��H�E��H��H�E��H��H�=��1��q�H��H��t%H��L��H�E��H��H�E��H��H�=v��1��-�H��H��t%H��L��H�E��N��H��H�E��H�w��H�=2��1��H��H��t%H��L��H�E�� H��H�E��\|��H�F��H�=��1��H��H��t%H��L��R��H�E��H��H�E��H��H��H�=��1��a�H��H��t%H��L��H�E��H��H�E��H��H�=f��1��H��H��t%H��L��H�E��>��H��H�E��H��H�="��1��H��H��t%H��L��H�E��H��H�E��H�e��H�=��1��H��H��t%H��L��B��H�E��H��H�E��x��H�0��H�=��1��Q�H��H��t%H��L��H�E��r��H��H�E��D��H��H�=V��1�� H��H��t%H��L��H�E��.��H��H�E��H��H�=��1��H��H��t%H��L��v��H�E��H��H�E��H�D$L�hM��L��E1��H��H��u��f�H��t.H��H�l$��H�\|$D�t$A��H��H�/u��H��u�E��bfD��E9l$tS��I��L��1��I��H��Y��H��L��I��6��H��I�u�L��-��E9l$u�I��H� ��1�H�=��H��H��t%H��L��c��H�E��H��H�E��I��H� ��1�H�=��k��H��H��t%H��L��H�E��H��H�E��I��H� e��1�H�=6�� H��H��t%H��L��H�E��A��H��H�E��j��I��H� &��1�H�=��H��H��t%H��L��H�E��H��H�E��,��I��H� ��1�H�=��H��H��t%H��L��7��H�E��H��H�E��I��H� ��1�H�=U��?��H��H��t)H��L��H�E��`��H��H�E�uH��^��I��H� D��1�H�=��H��H��t)H��L��H�E��H��H�E�uH��I��H� ��1�H�=��H��H��t)H��L��N��H�E��H��H�E�uH��I��H� ��1�H�=h��R��H��H��t)H��L��H�E��s��H��H�E�uH��q��I��H� r��1�H�=��H��H��t)H��L��H�E��$��H��H�E�uH��"��I��H� -��1�H�=��H��H��t)H��L��a��H�E��H��H�E�uH��I��H� ��1�H�={��e��H��H��t)H��L��H�E��H��H�E�uH��I��H� ��1�H�=,��H��H��t!H��L��H�E�u;H��H�E��M�mM��V��L��E1��H��H�E��H��D��H��?��H��s��H��H��H��H��C��H��w��H��x��H��h��H��X��H��H��G��H��8��{��H��(��H��H��L��H�� H��K��H��H��H��f��P��H��\��f��AWAVAUATUSH��H��(H�GH�D$�Q��H�D$H�CH�@H�D$��H��; ��H��E1��S��D��A��H��H��u��I��H��t��I9�tL��"��I��H��u�1��h��H�CI9�$x�� I9�$��I9�$��I9�$��$��I9�$��^��I9�$��I9�$��I9�$��I9�$x��F��I9�$��I9�$��I9�$� ��I9�$� ��.��I9�$� ��h��I9�$� ��M�t$M��H��uH�D$H;�F��H�CI9FP�c��I9FX��I9F`��I9Fh�-��I9Fp�s��I9�@��I9��I9��<��I9��I9��I9��M�vM��K��H�D$H�@L9t$�D��H9C�:��L��B��H��@��E1�A��fD��H��t4H��H�$A��H�<$H9{ED�H�/u�H�$��H�$H��u�A��L�K I��D��D)�H�=��L�$�r��L�$H�ڿ��H��A�х��H��([]A\A]A^A_�@�I��1�L�k H�=3��H� ��H�ڿ��H��A�Յ�u�H�CI9FX�e��fD��I��1�L�k H�=��H� ��H�ڿ��H��A�Յ��h��H�CI9F`�#��f.��I��1�L�k H�=��H� ��~��H�ڿ��H��A�Յ��H�CI9Fh��f.��I��1�L�k H�=K��H� t��.��H�ڿ��H��A�Յ��H�CI9Fp��f.��I��1�L�k H�=��H� 1��H�ڿ��H��A�Յ��x��H�CI9�@��Q��I��1�L�k H�=��H� ��H�ڿ��H��A�Յ��(��H�CI9��I��1�L�k H�=[��H� ��>��H�ڿ��H��A�Յ��H�CI9��I��1�L�k H�=��H� R��H�ڿ��H��A�Յ��H�CI9��I��1�L�k H�=��H� ��H�ڿ��H��A�Յ��8��H�CI9��E��I��1�L�k H�=k��H� ��N��H�ڿ��H��A�Յ��H�CI9��I��1�L�k H�=��H� ��H�ڿ��H��A�Յ��H�"��1�L�k H�=��H�ڿ��H��A�Յ��_��H�CI9�$��D��H��1�L�k H�=��}��H�ڿ��H��A�Յ��H�CI9�$��D��H��1�L�k H�=\|��5��H�ڿ��H��A�Յ��H�CI9�$��D��H�c��1�L�k H�=4��H�ڿ��H��A�Յ��H�CI9�$��m��D��H�%��1�L�k H�=��H�ڿ��H��A�Յ��?��H�CI9�$��3��D��H��1�L�k H�=��]��H�ڿ��H��A�Յ��H�CI9�$��D��H��1�L�k H�=\��H�ڿ��H��A�Յ��H�CI9�$x��D��H�>��1�L�k H�=��H�ڿ��H��A�Յ��g��H�CI9�$��D��H�?��1�L�k H�=��H�ڿ��H��A�Յ��H�CI9�$��K��D��H��1�L�k H�=��=��H�ڿ��H��A�Յ��H�CI9�$� ��D��H��1�L�k H�=<��H�ڿ��H��A�Յ��H�CI9�$� ��D��H��1�L�k H�=��H�ڿ��H��A�Յ��G��H�CI9�$� ��D��H�]��1�L�k H�=��e��H�ڿ��H��A�Յ��H�CI9�$� ��c��D��H�)��1�L�k H�=d��H�ڿ��H��A�Յ��-��f�H�3��1�L�k H�=,��H�ڿ��H��A�Յ��H�C�(��ff.��SH��H��H��t HcSH1�H��t[�fD��H��[�ff.��@�AUI��ATI��UH��SH��H��8�u��H��uCH�C@�$��H��L�l$H�P H�D$H�CPL�d$ H�l$H�T$(�PH��8[]A\A]�fD��ATSH��H��H�=W=��J��H��tEH�XI��H�H�@��{1�tH�C L��I�D$ ��H��L��[A\�H��fD��E1��ff.��H�=��SH�0=�t;H��G��H�=2��H����H�=f��H�;�S��H�=S��t8H��G��H�=��H��H�=��H�=��tRH��G��H�=��^��H��H�=~��E��H�Ə�H��tH�H�;H�5��1��H��G��H�=Y��H��;�H��[�ff.��@�AVAUATI��UH��SH�H��H��t H��Ӆ��I�\|$H��t H��Ӆ�uxI�\|$(H��t H��Ӆ�ueI�\|$0H��t H��Ӆ�uRI�D$@H��tFI�T$PH��t<E1�N�4�M��t I�~HH��t H��Ӆ�u M�v M��u�I�T$PI��I9�sI�D$@��1�[]A\A]A^�D��H��H9r��uH�N��H9Or��fD��AUATA��UH��SH��H��H�L�-�9�L9�t%L��uH��9�H��H��[]A\A]��H�}L9�tL��g��t�L�CH�}I9�tA��A��I9�H��IN�1�H��%��H��H9�tH�T�H�L�H9�t�H��I��A��H��Jc�H��1�I9��uH�e9�H��H��[]A\A]�H��9��D��1�I9��fD��1�I9��fD��1�I9��fD��1�I9��fD��1�I9��fD��H��8�H��H�9�H��H��H9�t H��H��,��H��f�H��H;5�8�L�Gt?H��8�H9Fu<H�wH�M��tI�(t1�H��L��fD��H�G��H��7�H�5��H�8��f��ATI��UH��H��H��tH��L��]A\�f.��H��8��I��H��t�H��7�H�8��t��H�EL�` H�@(H��tH�H1�H)�H�EM�dI��H��A��I�D$E��LE�H��]L��A\�f.��AWAVAUATUH��SH��H��L�%�7�L9��,��L9��H�F��H�BE1��L��H��L��H��I��I��M��H��M9��L9�t\|��H��L��ubI��L��tjL�� t^L��n��H��H��xPL��1��I��H��L��H�� I�/tZ��~ I��u0H��[]A\A]A^A_�@�1�H��[]A\A]A^A_��A��D��1�H9��fD��L��D$��D$�fD��L��L��y��f��AUATA��UH��SH��H��H�L�-�5�L9�t%L��uH�"5�H��H��[]A\A]��H�}L9�tL��tҋs�M9�tQA��H�=p��D��Hc�H��@�1�9��tH�n5�H��H��[]A\A]�H� 5��fD��H�uH�{H��D��[]A\A]��fD��1�9��1�9��1�9��ff.��@�H��H�ֺ��`��UH��SH��H��H�GH�xH�@�PH��t H�H9C H�Q�H�t0H��tH��4�H��H��[]�f��H��fD��H��tH�{(H��H��1�[1�]�%��D��H��fD��UH��SH��H��H�~H�5q4�H9�t �o��L�KPH�s@M��tgE1�H�H��H��u�Jf.��H�O H��t7H�PHH��H�@ H9�u�H��H�m��H��3�H��H��[]�f�I��H��M9�u�H�,3�H��H�5��H�81��H��1�[]��H�EH;�3��P��H;(3��C��H�PH��2�H�5��H�81��1��~��H��_��AUI��ATUH��SH��H��H��H_@H�H��u�JfD��H�P H��t7H��H9(u�H�h2�H�UH�5��E1�H�81��0��H��L��[]A\A]�f�H�X �h��I��H��tTH�xH�@��H��H�@`��)��Hh1��H�L�#H��M�l$@I�,$I�u0� ��I�D$HH��u�L��E1��H��\|��ff.��I��H9~ tH�H9xtH�~(L��f�1��ff.��f�AUATUH��SH��H�L�fH��H��tlH�;H��u�bfD��H�{(H��(H��tK�C��t��u�H�CH�MI9u�L�m �?��H��H��A�Յ�t��H��[]A\A]�D��L�eL��H��1�H��t�H�3H;ut%H��H��[��]A\A]�H�=��L�e ��H��H��A�ԅ�u�H�3�ff.��f�H��H�ֺ��H��H�ֺ��p��H��H�ֺ��`��AWAVAUI��ATUSH��L�wH�\|$H�=�/�I�^H��H��t^H��H�x1�H��(��H��H��~SE1��fD��J�D�I��L9�t:K�D�L��H�xH�@�PI��H��u�H�m�t=E1�H��L��[]A\A]A^A_��H�D$H��H�x ��I��H��tI�$H�m�u�H��[��t��H��u�H�D$H��H��H�x ��t�I��AVAUI��ATUH��SH�H��H��tkH�;H��tcL�f�D��H�{(H��(H��tK�C��t��u�H�CH�MI9u�L�u ��H��H��A�օ�t�[��]A\A]A^��I�}([H��]A\H�GA]A^��AUATUSH��H��H�FH��H��H��@��D�H+5��H�H��H��H)�1��f��H��H��H��uVH��.�H��I��H�{ L��T��I��H��I�$H�m��I�m�uFL��H��L��[]A\A]��H�� H��t�1�H��1��I��H��H�m�t.E1�H��L��[]A\A]�D��H�H��H)��;��H��x��H��L��[]A\A]�f.��{��H��O��H�{ L��L��7��M����f�H��(��+��I��ff.��AWAVAUATI��UH��H��SH��(��D$��H��tsI�$L�t$I��H��H�T$1�H�5I��L��1�H�T$L��L��H�5+��o��H��-�L��H�5-��H�81��I�,$t9E1�H��(L��[]A\A]A^A_��H�5I��H�R-�H�8�2��I�,$u�L��3��뽐Hc\$�v��H��H��U��1��A��H��H��u��H��H��H��u �fD��H��A��H��H��x��[��H9�u�D9\|$u�I�1�H�T$L��H�52��L��s��H�mH��H�D$�fD��H�mH��H9��u�Lc\|$1�H�T$L��H�5��D$��M�L�� HcD$A�<��H�� I��H��H��H��1��f��H��e��I��H�߃��Y��I�.H��u�L��ؽ��fD��H��H��E1�@��ý��D��A��H��H��u��I��H��E1��fD��L��A��茽��I��H��I9�u�I�EH��t�H�T$�fD��H�@H��t�H9��u�D)�L��H�=��1��ػ��I��H��H��H�J�H�Ӟ��H�81��L��H��I��I�m�tI�,$�k��L��Լ��^��L��Ǽ��A��H�5H��]��H�=[�L�5�[�H��u��fD��I�~(I��(H��L��u�L��H��h��I��H��u��H�]�H�;L��H�5ȝ��1�E1��N��R��H�=�X�L�-�X�H��u�tf.��I�}(I��(H��t]L��{��u�L��H��I��H��H��)�H�;L��H�5$��1�E1��H��)�L��H�;蛼��Q��H��)�L��H�;脼��I�E�L�� H��t+H��I�ރ��H��9l$�r��I�.u�L��R��I�m�t2H�J)��T$H�5W��A��H�81��7��I�,$��;��L��ff.��f��1�H�G t�D��AVH��H� ��H��AUATUS�2�H��HD�H��n��{2�t8H�C H��H��1�H9��H�SH�C(�C1[]A\A]A^��H�s H��H��~�H�{H��L�,7H�oL�g I9�w,��D��I�D$�H9�t�AoD$�E�H��I��M9�vVI�\|$�M��H;}�u�M�D$�L;E�u�H�/tOI�(u�L��H�{H��;��H��H�C �C��H��H+CH��H�C H��軹��M�D$��H�C ��D��H�'�H��`�H�'�H��` �H��&�H��`(�H��&�H��`H�I��H��H��L��.��H��ff.��ATI��I��UH��H�L��H�xH�@�P H��t]I�\|$H��H��ݹ��A��H�E�A��tH��A��H�E�tH��D��]A\�H��H�E�uH��ø��H��D��]A\��A��UH��SH��H��H�H�5�%�H9�t �o��t3H�}�H��诺��H��H��tOH�}�>��H��[]�@�H�CH�5]��H�PH�r%�H�81��8��H��[]�@��3��H��uH�}�H��H��_��t H��D��f��ATUH��SH��P��H��t@H�} �I��~91��D��H��H9] ~&H��L��H��HEH�p�w��u�I�,$tE1�L��[]A\�L��E1��u��L��[]A\�ff.��f�ATUH��SH��з��H��t?H�} �I��~81��D��H��H9] ~%H��L��H��HEH�0��u�I�,$tE1�L��[]A\ÐL��E1��L��[]A\�ff.��f�UH��SH��H��H�?H�sH��S��t0H��[]�f��H�~H��脷��tҺ��O�H��[]ÐH�{ H��H��[]��ff.��AUATUSH��H��H�~H��7��A�ą��H�[��t��H��u�H�{0L�-��L9�t=H�=(x��tv�ɷ��H��H��H�=x�H��H��K��thL�k0H�m�t3H��D��[]A\A]�D��A��H��E��[]A��D��A\A]�@�H��蠵��fD��c��H��w�H��tH�{0�p��H�m�uH��o��A��H�G��t ��t 1��L�F(H��L��H��"�H��`P�UH��SH��H� w�H��t�H�{H��̻��trH�[H��u�H�u��t�H��u�H�=�v�H��t$��H��H��tE�Ҷ��H��H��[]��H�F0H�u��H9�t�H��H��[]��H�5��H�=g��H�5��H�=4��ߵ��ff.��@�H��!�H��`X�ATUH��SH�~H��H�� A�ą�t��DO�D��[]A\�f�H�{H��蔴��u�H�{ H��[]A\�`��ATE1�UH��SH�~H��H��g��tD��[]A\��H�{H��蜴��tDN�[]D��A\�@�H�{ H��[]A\��UH��SH��H��H�H��H�x��A��1�E��tH��[]�@�H�{H��4��H��[]��f�H�� H��``�ATfHn�fHn�1�Ufl�SH�� )$�߱��H�D$H��H�\|$H��H�5R��ݵ��t=H�\|$1��L��H��H�� Jf�H��H9�t?H�D$H�\|$H�@H�4�耹��u�H�\|$A��H��u H�� D��[]A\��H�\|$E1�H��t�H�/u��p��H�� D��[]A\�A��ff.��H��H��`0�H��H��`8�I��H��I�p �a��H��H��`@�ATH�=��UH��M��H��tPH��H��1�H�_��H�5��m��H�m�I��tH��L��]A\��H��踱��H��L��]A\�D��E1�H��L��]A\�f.��H��ttAVAUI��ATI��USH��tQ1�fD��I�,�H��u�5D��H��M��t#L��H�}HL�u H�/u��=��H��հ��M��u�H��I9�u�[L��]A\A]A^鷰��fD��AWf�AVAUATUH�o0L�G@L�H�G0��H�wPL�wH�G@��L�o L�g(GG L��觶��M��t I�/��M��tI�.tmM��tI�m�tQM��tI�,$t5H��tH�m�t]1�A\A]A^A_�D��H��p��]1�A\A]A^A_�@�L��X��fD��L��H��fD��L��8��fD��L��(��k��ATUH��H��H�5��H��"��u&H��H�EH��H��@��H��]A\��賲��H��H��I��U��u1H��H�EH��@��M��tH��L��]A\��H��]A\��H�GPH��H�@H��HD�H�G�D��H�GPH�x�tH��G`��H�G�f�H�H��tH�\��G`��H�G�H�9��G`��H�G�ff.��f�H�GPH��H�x �H�ٶ��HD�H�G�ATUH��SH��H��H�� H��H�W@H��%��H��H��u��H�[ H��H;3u�H�'V�H9��H��I��H��H�X(H�CP�{`I�D$PuWH�C0A�D$`��I�D$0H�CI�D$H�C8I�D$8H�CXI�D$XH�CI�D$H��I�D$H��L��[]A\�f��L��(��fD��H�\|$��H�\|$H��H�wU�H9��P��H��L�%cU�L��[]A\��H��0�I��H��t�H��U�L��I�D$P�ı��L��L��4��H��L��[]A\��UH��SH��H��H�>H�uH��H�W@H��%��H��H��u �f�H�@ H��tH;0u�H��PHCH��1�[]��3��ߐAUATI��UH�>L�nI�t$H�W@H��H��%��H�,�H��u�I�H�m H��t?H�E�H9�u��uC�E`��tK��tXH�EL��L��H��H�D�]A\A]��D��H��I�D$��t�L��z��E`��u�]1�A\A]�f.��I�D$]L��L��H�5��A\A]H��ATUH��SH�vH��H�H��H�W@H��%��H��H��u�S�H�@ H��tGH;0u�H��PH��购��H��H��tLH�{ H�� I��H��tHI�$H�m�tL��[]A\�@��f��H��訫��L��[]A\�E1�[]L��A\�D��H�{ H��H��t�I��U1�H��H� �F�H��H��H��H��L��L�L$衯��H�t$H�U@H��H��%��H��H��u�yf��H�@ H��tgH;0u�H��R�H9�tD�P`��t#H� ��@`��H�HH��H��H��]�H��H�5��H�8被��H��1�]�f.��H��fD��AU1�ATUH��H��H�5[��SH��(I��H�L$L��'��L�$$H�U@H�D$��I�t$H��H��%��H��H��u �zf�H�[ H��toH�H9�u��u>�C`��t��tqL��H��L��H��S��t)H�\|$觫��H��([]A\A]�@�L��Ю��fD��H��(1�[]A\A]��H��H��I�D$��t��D��I�D$L��H�5 ��L��ff.��U1�H��H� �D�SH��H��H��H��L��L�L$蠭��trL�T$M��X��M��tKI�[H��~BE1�L� ��fD��I��I9�t'K�D�H�P��t�H��H��u-I��I9�u�H� �H�5��H�8躩��H��1�[]ÐH��(H�2H��t�� L��u�H�ZH��t�L��H�U@H��%��H��H��u�d@�H�@ H��tWL;u�H�P�H9�t��P`��tHH�PH�XXH��H�@0H�P8H�X�@`��H��H��H��[]��L��H��-��H�4�H�5U��H�8��1��ːAT1�I��H� RC�UH��H��H�̜��SH��L�L$L�D$��H�T$0H�Y��$��H��H�D$ 1�I�T$@�H�H�D$L�d$�D$(��H�pH��H��%��H��H��u��H�[ H��H�+H9�u�H��+��t(H9l$�k��H��H��H��S��t�D$(��E1�H�\|$0H��t H�/��H�\|$8H��t H�/�{��H�\|$@H��t H�/�w��H�\|$HH��t H�/�s��H�\|$PH��t H�/�o��H�\|$XH��t H�/�k��H�\|$`H��t H�/�g��H�\|$hH��t H�/�c��H�\|$pH��t H�/�_��H�\|$xH��t H�/�[��H��$��H��t H�/��H�Đ��L��[]A\�D��ި��I��H��1��0fD��c��H��H��V��H��L��H��X��H��H�\|�0H��u�菨��H��f.��L��H��H�D$H�h�T��若��H�Đ��L��[]A\�@��s��w��fD��c��{��fD��S��fD��C��fD��3��fD��#��fD��fD��fD��fD��fD��H�Đ��E1�L��[]A\�fD��H�=��L�d$ H��H��H��A�ԅ��n��w��I�,$�x��L��~��k��f��AUATI��UH�>L9��I��L9f��L9f��L9f tL9f(tyL9ftsL�f0I�t$H�W@H��H��%��H�,�H��u��@�H�m H��tH�E�H9�u��u=�E`��t%��t@H�EL��L��H��H��N��]A\A]��D��]1�A\A]��L��訨��fD��I�D$]L��L��H�5MN��A\A]H��H��I�D$��y��@�H� �ף��UH��H��H��H� �>�H��HH��L�=�H�T$@�D$@��H�D$0��H��H�@RH�T$8RAPH�T$0RPH�T$8RH��P1�L�L$`�F��H��@��t^H�D$(H�,$H��tH�x �tYH��q��H�D$H��t7H�\|$H��H�58��蓥��tH�D$H��@]��H�\|$H��tH�/t H��@1�]��H�D$(��D��[��f��AWH� w=�AVAUATI��H��H��UH�P��SH��8H��H��H��L�@H�D$P1�APL�L$�f��H��L��L�$$蟨��1�H�D$賠��H�\|$H�D$ H��u��H��{��H�\|$H��H�5x�L�%q�蜤��C��H�\|$ ��H��L�\|$ L��I��H��H�X�L��H��ŧ��I��H��H��1�L��H��L��%��I�uH�<$H��H�W@H��%��H��H��u��H�[ H��H�H9�u��C`��t��H��L��L��H��S��tTI�m��L��趠��H�\|$ ��H��H�t$H�<$�e��t0H�\|$ H��t H�/��H�D$�?I�m��f.��H�\|$H��t H�/��H�\|$ H��t H�/��1�H��8[]A\A]A^A_��;�H��I�E��L��f.��I�EH��L��L�� j��H�� H�5��H�81��¥��H�\|$�M��裟��H�\|$ H��S��X��苟��N��L��~��t��ff.��@�AWH� g:�AVAUATI��H��H��UH�`��SH��8H��H��H��L�@H�D$P1�APL�L$�v��H��L��L�$$该��1�H�D$�Ý��H�\|$H�D$ H��u��H��{��H�\|$H��H�5��L�%��謡��C��H�\|$ ��H��L�\|$ L��I��H��H�X�L��H��դ��I��H��H��1�L��H��L��5��I�uH�<$H��H�W@H��%��H��H��u��H�[ H��H�H9�u��C`��t��H��L��L��H��S��tTI�m��L��Ɲ��H�\|$ �,��H��H�t$H�<$�u��t0H�\|$ H��t H�/��H�D$�?I�m��f.��H�\|$H��t H�/��H�\|$ H��t H�/��1�H��8[]A\A]A^A_��K�H��I�E��L��f.��I�EH��L��L�� j��H�� H�5��H�81��Ң��H�\|$�M��賜��H�\|$ H��S��X��蛜��N��L��莜��脜��ff.��@�ATI��UH��SH�^H�W@H��H��%��H��H��u�g��H�@ H��tWH;u�P`��t]��tuH; �tlL��H��1�H��t_H�:H��tWH�� H�0�3��H9E [��]A\��@�H��H��P`��u�H�@XH�M []I9A\��fD��[]A\�fD��UH��SH��H��H��H�;�y��u H��[]�fD��H�{H��ܝ��H��[]��f.��UH��SH��H��H��H�;�)��tH� &�1�H9MtH��[]��H�{H��t��O�H��[]�f��H�{H��H��[]�N��ff.��AWAVI��AUATUSH��H��0��H��H�I��H�5ݏ��H�XL��H�@��H�4�I�D$(��I�D$ I�D$P��A�D$H��I�D$0��I�D$@��H��I�D$0H��tH��I�D$PH9�v+I�D$@��I�,$��E1�H��L��[]A\A]A^A_�f�H�<��s��I�D$@H��H��t�I�D$PH��tH��1�� H��I�D$(H��t�H�W�H�sH��tCfD��L�� H��H��r��H�XPH��H��@贝��H��H��$��H�sH��u�H��H�sH��t@�L��H��H��"��H�XPH��H��@�d��H��輘��H��ԛ��H�sH��u�E1�L�=f��L��I9��L��L��$��H��H��H9E��H��蘘��.��H��H��H��H��L��H��H��躞��H��H��l��H�pH��tBD��L��H��H��J��H�XPH��H��@茜��H��H��H�sH��u�I����f.��L��(��H�\�H�5�{��H�8��H�A�H�5�{��H�8��ff.��f�UH� �3�H��H��H��H�+��H��L� ��H�D$��H�D$H�D$��P1�L�D$��A��X1�ZE��tH�$H�t$H��,��H��]�fD��U��SH��H��0��H��t�hH��tH�XH�H��[]�fD��H��ff.��@�U1�H��H� �1�H��H��H�t��H��L�L$L�D$�S��t�t$�F�� w#H�T$H��膗��H��]�H��1�]��H��H�5�z��H�81�豜��H��1�]�f��H��H�=��/��ff.��@�AUA��ATUH��SH��H��B(��H��taH�s8H�{@D�nH�n�\|��I��H��tdH�{0L��t�C(��H�m�t�C(H��[]A\A]��H��fD��H��}��H�-��H�E��@�H��D��5��I��H��t�H�{@H��H��I�$t%H��I�$�c��L��菕��V��f.��H��I�$�V��L��j��I��I��ff.��AWAVAUATUSH��8H�<$H�t$H�T$�ߛ��1�H�D$��L�D$H�D$ H��H��l��M��c��H�$H�hH�}��H�t$H��T$A�ą��$��H��H�\|$ �6��H��L�\|$ L�� I��H��H�X�L��H��I��H��H��1�L��H��L��U��I�uH�<$H��H�W@H��%��H��H��u��H�[ H��H�H9�u��C`��t%��H��H�#��L��H��S��I�m��L��ޓ��H�\|$ �D��H��H�\|$ H��u?H�\|$H��t H�/��H��8D��[]A\A]A^A_��H�\|$ A��H��t�H�/u��w��D��H��I�E��9��L��O��,��f.��I�EH��H�5R��L��/��I�m�u�L��A��H�\|$ �z��H��H�5"��H�81��R��ߒ��-��H��L��诓��A�ą��DO��H�\|$ H��A��A��fD��AWAVAUATI��USH��(H�<$�&��1�H�D$�:��H�\|$H�D$H��H��H�<$H�oH��.��_��H�'��H9E�N��H��f�H�\|$膖��H��L�\|$L��p��I��H��H�X�L��H��E��I��H��)��H��1�L��H��L��襑�� I�uH�<$H��H�W@H��%��H��H��u�'��H�[ H��H�H9�u��C`��t%��H��H��L��H��S��!��I�m��L��.��H�\|$蔕��H��H�t$H�<$��tXI�\|$(讔��H��H��6��H�\|$H��t H�/��H�D$�IH�\|$H��誑��O��H�\|$H��tH�/t!H�\|$H��tH�/t1�H��([]A\A]A^A_��z��s��H��I�E��L��O��f.��I�EH��H�5��L��I�m��e��L�� H�\|$�X��J��H��H�5��H�81��H�\|$�-��H�\|$H��;��H�-��L�l$H��I�}H�pH9��臕��I�}H�5,��H9��f��I�E��I�}��_��H��I;]�P��I�EH�,�H�E�H�PH�U�H�U��t ��tGH�E�H��u�H��L��H�5��L��5��L��H�5{��L��I�\|$(H��褏��H�m�A��A��A��M��L��I��H��L��ю��H��H��t'H�@��t ��tDH�m�u�H��T��m��H��$��I�m��G��L��1��:��H��$��i��I�\|$(H��H�m��t��t��m��H��ff.��ATUH��SH��H�F��H�<$H�}H�D$��H��H�pH9�t 蜓��t8H��H�5.�H��膐��H�\|$�C��I��H��L��[]A\�@�H�}H�5 ��H9��G��H�E��1�H�}�~�D��H�EH�<$L�$�H�W@I�t$I�$H��H��%��H��H��u��@�H�@ H��H;0u�L��PHD$I�,$��H��H;]\|��4��H��H�5F��H��辐��H��E1�L��[]A\�H��ޑ��H��H��t�fD��H��Ȍ��I��H��H�pH�<$H��H�W@H��%��H��H��u�if��H�@ H��tWH;0u�L��PHD$I�,$u�L��fD��+�� fD��L��H��H9]��X��D��H��uH�m��7��H��輋����H�m��H��褋��ff.��@�AVAUATUH��SH��H�<$�(��H�D$H��H��H�}H��H�pH9��:��H�}H�5��H9��H�E��E1�H�}�I��`��tQI��L;u}GH�EL��N�$�I�$L��I�,$��u�L��迊��D��H��H�5��H��薍��tIH�t$H�<$�c��t6H�D$H��[]A\A]A^�藍��H��I�,$uL��_��H�\|$H�/tH��1�[]A\A]A^�fD��3��H��H�5��H��.��s��f��H��X��I��H��t�I��t:L��2��H��H��Z��L��H��H�m��u�H��躉��I�,$��L��蝉��AWAVAUATUH��SH��H��(H�G8H�H�D$��H�D$H��I��H��H�}H��H�pH9��,��H�}H�5��H9�� H�E��B��E1�H�}�L�t$�j�A��A��tYI��L;}}OH�EL��N�$�I�$L��I�,$A��u�L��謈��f.��H�T$H�5��H��\|��tgH�\|$�݇��tXH�l$H�{0H��觊��H��t2H�\|$H��H�/u@H�D$�I��H�D$H��([]A\A]A^A_�D��K��H��tFfD��H�\|$1�H�/t�H��([]A\A]A^A_�@�H�T$H�5T��H��[��H�{0H��H��1��t�H��b��@�H��I��H��t�L�l$�f��A��t\A��t4L��܇��H��H��t<L��H��H�m�A��u�H��g��D��I�,$��L��M��c��H��t�I�,$��L��+��fD��AUATUH��SH��H�<$芆��H�D$H��H�m��H�}H��H�pH9�t �Ќ��t,H��H�5B��H��躉��H�D$H��[]A\A]ÐH�}H�5M��H9��臌��H�E��1�H�}��I�,$��H��H;]}�H�EL�$�H�$I�$H�xL��Ά��u�H�\|$L�� I�,$A��thA��u�f�H�\|$H��tH�/t1�H��[]A\A]��1��H��H�5F��H��މ��f��L��踅��N��L��訅��fD��H��I��H��t�L��؅��H��H��trH�$H��H�x��tH�m�u�H��]��H�\|$H��1��)��H�m�t"��u�I�,$��L��"�� D��H��)��H��u�I�,$�8��L��+��ff.��AV1�AUATUSH��H��H�5Bz��H��0H�T$�{��H�\$�y��H�D$H��H��H�l$H��H�}H�pH9�t �j��tvH�T$H�5��H��R��t5H�D$H��0[]A\A]A^��f��H��m��I�,$uL��.��fD��H�\|$H��t H�/��H��01�[]A\A]A^�D��H�}H�5��H9��׉��H�E��E1�H�}�L�l$+�]��f.��t��E��I��L;u�7��H�EL��N�$�I�$L��蜐��I�,$��u�L��k��f��[��B��fD��H�T$H�5d��H��L��H��x��I��H��L�l$�D��t2L��J��H��H��L��H��H�m��u�H��҂��I�,$�h��L��轂��[��AV1�H� %�AUATI��H��H��UH�x��SH��L�D$��L��A��$0��I��H��txH�jD�1�L�%aD�I�D$��I�D$H��tMH��H�l$H��H�}H�pH9�t ��tXL��H�5��H��tL��L��u�I�,$tE1�H��L��[]A\A]A^�fD��L��ȁ��fD��H�}H�5]��H9�tp蛇��ugH�E��tqE1�H�}�$�fD��t��y��I��L;u�k��H�EL��N�,�I�E�L��I�m��u�L��C��빐L��H�5��H��>��#��H��q��I��H��u�$��@��tU��t.L��N��H��H��t6L��H��{��H�m��u�H��ڀ��I�m��L��ŀ��ۃ��H��t�I�m��L��裀��ff.��AVAUATUH��SH��H��L�-��H�}I�E�H�pH9�t �Q��H�C H�PH�z ��H�{H�$��H�D$I��H��I�E�H�}H�pH9��H�}H�5��H9��r��݅��e��H�E��E1�H�}��D��I�.tjI��L;m��H�EN�4�H�$H�xH�@L��I��P I��H��H�\|$H��U��I�$��H��I�$u�L��V��I�.u�L��H��fD��H�y��H�5bc��E1�H�8��H��L��[]A\A]A^��H��H�5��H��tqH�\|$�O~��tbH�l$H�{8H��I��H��I�$H�\|$H�/u��~��H��L��[]A\A]A^�H��I�$��I�.uL��~��@�E1��H��H�5F��H��~��k��f��H�{8H��蔀��I��H��tLI�$H��L��[]A\A]A^��K��H��u�H�{8H��H��w��t�I��=��f.��H��H�{8H��H��C��I��H��I��H��9��L��~��H��H��tZH�$H��H�xH�@�P I��H��ttH�\|$H��i~��I�$tLH��I�$tH�m�u�H��g}��D��L��X}��q��H��u9I�m��H��L��9}��;��H��I�$uL��"}��H�m�uH��}��I�m��L��E1��\|��0��I�.�f��L��\|��L��\|��:��@��wtI��I��H�=nw��H�։�Hc�H��I9��I�AH��I�yL��H�@(��I9�t[I�AI�yL��H�@(��f.��1�I9��1�I9��H��H�\|��H�5�`��H�8�-}��H��1��D��D��ATI��USH�H��L��H�xH�@�PH��tX�KH�SH��H��H�;蛁��t7��u"H�m�t[1�]A\�@�H��{��fD��H�{L��$~��u�H�m�t[��]A\�fD��H��{��ff.��AWI��AVAUATUSH��H�WH�BH�D$H��H��E1��'�I��M��I��L9d$��I�WI�D$I�O0H�T�H�\|�L�jI�W(H�T�H�$�A~��I�}H��I��I�E�PH�$H��H��t4D��H��L��膀��H�m�Lc��x��H��z��I��p��fD��E1�H��L��[]A\A]A^A_�E1��L��H\|��H��H��t�I� H��\|��I��H��tI�$H�m�u�H��Xz��q}��H��u�I� H��H��t�I��AUATUSH��H�G��t{��1�H�=�o��L�-��H��H��I�\|��H��t"H��A��_\|��u�H��D��[]A\A]�D��H��H�5�^��A��H�8�z��H��D��[]A\A]�H��H�58^��A��H�8�rz��AV1�AUATUSH��H��H�5o��H��0H�L$H��L�D$�}��H�\|$�1y��D$(��r��H�S��vH�z(��<��H�B H�t$H��R��H�{��H�D$H��,��1��w��H�D$ H��H�J��H�,$H�\$H��H�}H�pH9��~��H�}H�5E��H9��~��H�E��e��H�}�~tE1�L�l$�D��tWI��L;u}MH�EL��N�$�I�$L��I�,$��u�L��x��D��H�T$H�5��H��z��H�\|$H�/tpH�D$ H��0[]A\A]A^�fD��H��H�5�\��H�8�x��H��01�[]A\A]A^��H��H�T$H�5t��H��{��f.��{w��z��H��I�,$uL��\w��@�H�\|$ H�/t5H�D$ ��D��H�a��H�5\��H�8�x��1��0��w��H��Y\|��I��H��t�L�l$�f.��t��t2L��.w��H��H��Y��L��H��H�m��u�H��v��I�,$��L��v��ff.��ATUH��H�={��SH��w��I��H��tH�E�fHn�fHn�H��fl�@�w��L��[]A\�ff.��UH��H� �H��H��k��H��hL��H�D$HPH�D$HPH�D$HP1�L�L$H�bz��H�� tj��x��H��H��tXH�D$(H�5\|�H��H�EH��H�D$0H�E H��H�D$8H�E(H��H�D$@H�E0H��z��H�m�tH��`]��H��`1�]��H��H�D$�su��H�D$H��`]��H�5y��z��@�USH��H��H�5�j��H��XH�F��L�'��H�D$HH�L$8P1��5��L�L$@��x��ZY��tt��w��H��H��tbH�XH�D$8H�5 �H��H�H�E(H�D$8H��H�D$0H�E H�D$0H��H�D$HH�E8H�D$HH��y��H�m�tH��X[]��H��X1�[]��H��H�D$�{t��H�D$H��X[]�ff.��@�AT1�USH��H��H�5j��H�� H��H�L$�w��H�=h6��tV��v��H��H��H�XH�D$H�5`�H��H�H�E H��y��H�m��H�� []A\��H�=�i��v��H��v��H=��H�=�i��v��H��H��H�5�i��H��Ys��I��H��H��u��H��H��5�H�E�x]H��H�E��I�,$�&��L��Ds��H�� 1�[]A\�D��H��H�D$�s��H�D$H�� []A\�D��H��H�E�t^I�,$tG�Ru��H��H�2X��H�5��H�81��Uy��H��4��L��r��fD��H��r��fD��H�m�u�H��r��H��pr��ff.��H�5��w��@�USH��H��H�5Ah��H��XL��H�?��H�D$HH�L$0P1�APL�L$P��u��ZY��t��H��H��tqH�XH�D$0��H�H�5��H�E H��H�D$@H�E0H��H�D$HH�E8H��r��H�E(H��t!H�5��H��v��H�m�tH��X[]�@�H�m�t H��X1�[]�H��H�D$�sq��H�D$H��X[]��U1�SH��H��H�5`g��H��(H��H�L$�t��tF��s��H��H��t4H�XH�D$H�5��H��H�H�E H��0v��H�m�tH��([]�f�H��(1�[]��H��H�D$��p��H�D$H��([]��H�5Y��u��@�H�5��u��@�AVH��1�H�5�f��AUATUSH��PL�Q��H�j��H�L$(L�L$0�+t��H�D$(L�`M��1�H�\�H�C��H�{��H�CH�5��H�xH9�t2�v��u)H�J��H�5�U��H�8��p��1�H��P[]A\A]A^�@�H�{(H�G��[��o��t'H��I9�t0H�D$(�g��fD��I�.uL��o��H��P1�[]A\A]A^��Vr��I��H��t�H�D$(L��I�FH��H�D$0I�F H�D$0H��'r��L��I�F(�r��I�~(�I�F0t�E1�M��S��H�z��H��H��n��I�F(H�t�H�{(�n��Hc��q��H��K��I�V0I��H�D�M9��H�D$(I�mH�\�H�SH�s H�BH�@ H��u�H��@�H��H�5�d��H�8�o��1��H��H�5�d��H�8�ro��1��H��H�5ZT��H�8�Ro��1��b��H�5��L��\|s��I�.�I��L��H�D$�5n��H�D$�2��ff.��USH��H��H�5wd��H��XH��L��H�D$HH�L$0PH�D$HP1�L�L$H�q��ZY��tl��p��H��H��tZH�XH�D$0H�5��H��H�H�E H��H�D$8H�E(H��H�D$@H�E0H��H�D$HH�E8H��r��H�m�tH��X[]ÐH��X1�[]��H��H�D$�Sm��H�D$H��X[]��UH��1�H�5�c��SH��HL��H��H�L$(L�L$0��p��H�=��n��H�D$(H�HH��~5H�-��1�H�T�H�zH9�tH��r��tkH�D$(H�HH��H9�\|Կ��wo��H��H��t]H�D$(H�5��H��H�EH��H�D$0H�E H��q��H�m�u/H��H�D$�bl��H�D$��H��H�5jR��H�8�2m��1�H��H[]�f��AUf�ATUSH��H�o L�gG H�G��H��~JL��E1��H�{H�/t%I��H��L9�tH�;H�/u��k��H�{H�/u��k��I��H��L9�u�H��L��[]A\A]�Mk��ff.��f�UH�oH�G��~r��H��tH�m�t 1�]�fD��H��pk��1�]�ff.��AWAVAUATI��H��H�5�Q��USH��HI�D$ H�I��H�L$(L�d$ H�D$H��H��I�D$ 1��n��gk��I��H��H��co��H��H��H�\|$(E1��q��H�D$ H�D$H��fD��I�GN�4��D$8��L9t$(��I�~H9��H��p��H��I�~H��H�pH9��Xp��I�~��L��L�L$ H�D$0H��H��I�I@%��L��M��u��M�@ M��I98u��A�@`��t(��H�L$H��L��L��A�P��I��L9��H�\|��H��I��H�D$I�D$ I�/��H��HL��[]A\A]A^A_��H�D$I9F L��HD4��&��H��L��荺��I�~I��H��L��L�D$�Ln��L�D$�1��f�I�FH�T$H�5 ��L��9��f�H�D$E1�I�D$ �]��fD��L��i��J��E1��+��H��o��H��H��H��AUATUH��SH��o��H�5��H��g��k��H��H��I��$k��L�mH�E��H��ho��M��tI�m��H�} �L�E~-1��I��I��K�(H�:H�/tlH�zH�/tJH��H9] �L��g��H�EH��@��M��tH��L��[]A\A]�l��@�H��[]A\A]�D��g��H��L�EH9] ��g��L�EK�(�f��E1��,��L��g��;��AUI��ATI��UH��SH��2�H�G u#H��tH�OH��H��H�T�H92��D��H9E(~JH�UH��fIn�fIn�I�$fl�H��I�E�H�� E1�H�E 1�H��[]A\A]�f.��H�X1�H��H��H��H��u�H��H�H��H��H9�v-H�E��f�E ��f��뜐L9j�V��1��f�H�}H��H��g��H�EH��H��t�H�](H�E �1��ATI��USH�H��L��H�xH�@�PH��tXH�{L��H��H��i��A��H�E�A��tH��A��H�E�tD��[]A\�H��H�E�uH��f��D��[]A\��A��AWf�AVAUATUSH��H��XH�\|$0H�t$@)D$ �We��H�D$8H��r��H�{(�pi��H��H�{(�.k��H�D$H�D$ H��/��e��H�D$H�D$(H��;��H�D$ L�t$0H�D$H�$H�(H��i��H��H��E1�H��~VH�EN�$�L��@j��I��H��t5H�0H��t-H�\|$@L��h��I�u�H�\|$8��e��I��L9�u�H�$H�$I9��x��H�D$L� L��Hi��H��H��D��L�-��1��6�L��(k��tI�GL��H�5� ��L��tPH��H9��I�D$L�<�M9ou�H�\|$8L��Oe��t"��u�H��H�\|$@L��g��u�D��A��H�\|$8H��t H�/��H�L$H�H�$H��H�tiH�\|$�tH�L$H�H�$H��H�tdH��XD��[]A\A]A^A_�f.��H�5��H��H��>��H��H��tZH�(��c��f�H��c��H�D$(H�D$�@�H��c��fD��H�D$H�D$I9��E1����H�\|$8H��tH�/u�Wc��A��P��Gc��f�U1�H��H��H�5�Y��H��H�5��H�L$��f��t'H�t$H�� tH��H��H��]�@�H��1�]��AWAVAUATE1�UH��H��H�5aY��SH��xH�3��H��H�L$0L�L$H��L�@1��\f��3��H��H�l$�7i��H��H�D$ �i��H��H�D$(�i��1�H�D$H�1a��1�H�D$8�%a��1�H�D$P�a��H�=��H�D$X�Xg��H�\|$ H�D$@H��B��L�d$(M����L�d$HM��L�d$8M��H�\|$P��H�\|$X��H��H�D$L��L�l$H�p�4d��K��H�\|$8�!f��H��q��L�t$8L��f��I��H��L�x�L��L��g��H��H��H��1�L��L��L��@a��H9l$@��H�uH�\|$H��H�W@H��%��H��H��u��fD��H�[ H��H;3u�{`��H�\|$H��H��~a��A�ą��H�\|$ H��]a��H�\|$HH��a��L�%X��A��H�\|$PH��b��T��H�\|$XL��b��>��H�t$@H�\|$8��b��&��E��uAH�E��C`��t(��\��L��H��H��H��S��H�m��J��H��_��=��E1�H�/��H�\|$(H��t H�/��H�\|$HH��t H�/��H�\|$8H��t H�/��H�\|$PH��t H�/��H�\|$XH��t H�/��H�\|$@H��t H�/��M��tI�$H��xL��[]A\A]A^A_��C_��H�\|$(H��\��a��+_��H�\|$HH��X��]��_��H�\|$8H��L��Q��^��H�\|$PH��@��E��^��H�\|$XH��4��9��^��H�\|$@H��(��-��^��M��D��f�E1�H�\|$ H��\|��m��f.��k��H�Ã{`�:��A��Y��L�\|$PL��b��I��H��H�X�L��H��hd��I��H��H��1�L��H��L��]��H�\$XH��Cb��I��H��H�p�H��H�t$�d��I��H��t~H��H�t$1�L��H��x]��xdM��t_H�\|$HL��Rd��t0L�=.��I�$M9�t]H��H�\|$ L��6^��I�,$��I�.uL��4]��@�H�m��H��E1��]��D��H��~H�\|$(L��]��t�H�\|$P�^a��H��tPH�X�H�\|$PH��8c��H��H��H�\|$0L��_`��i��I�H�\|$XL��H��`��L��I�$H��I�$��I�.�m��L��u\��`��uH�/��H�5�Q��H�81��fb��fD��E1��h��H�D$H9h�!��A��L��fD��H�\|$(H��\��A�ƅ��a��A��L�%��X��f�H��H�5Q��H�81��a��c��H�EL��H�55��H��z��H�k��H�5�P��H�81��a��]��H��`��@��L��x[��L��k[��$��H�\|$H��t1H��[��E��L�%��L�%��H�D$H9ht��ff.��ATE1�UH��SH��H��H�;��^��tD��[]A\�@�H�SH�{H��A��u^��tD��C[]A\�A��ff.��U1�H��H��H�5PQ��H��H�L$H��O^��t+H�T$H�4$H��^��tH��H��H��]�@�H��1�]��H��H��H�VH��H�8��]��H��f.��H��H�G��t/H�u(I��H�W H�wL��]��H��D��H��H�5R@��H�8�Z��H��H9Gt1��UH��SH��H��H�~H��xZ��t��t1�H��[]�fD��H�{H�%��H�� ]��AUI��1�H��ATH�5�O��USH��(H�L$H�T$L�D$��\��tuH��H�l$H��H�}H�pH9�t �^��tbH�T$H�5��H��[��t7H��H��H��([]A\A]�H��H�E�uH��X��I�,$uL��X��H��(1�[]A\A]�D��H�}H�5E��H9��^��u{H�E��1�H�}��{��@�A��t�H��H;]�c��H�EH�T$H�\|$L�$�I�$L��[��I�,$A��u�L��X��fD��H�T$H�5��H��\��H��8]��I��H��"��@�L�� X��H��H��t3H�T$H�\|$H��V[��H�E��H��H�E�u�H��W��Z��H��I�,$��L��tW��~��ff.��@�H��0��H��t1��@2�f�f�P0@ @H��ÐSH��H��H��X��H��t'H�SH�xH�PH��tH�H��tH�/t�S0�P0H��[�D��H�D$��V��H�D$��H�O H�GH��~1Ґ�o�H��H��f�@�H9�u��G1�1��ff.��@�H��gX��tH�+��H��H��f�1��ff.��AUI��ATI��UH��SH��H��1��I�} M�EH��L��L�I��I9�r��H9��H9��L��H��H)�H��H��?H��H�H�H��H�H�H9�u�H��I9�r� �H��I9�sH9X�t�H��H9�vH9u H��H9�w�H�E�1�I�$H��[]A\A]�D��M�$1�L�E�H��[]A\A]��Kj��6��fD��I�$1�H�U�H��[]A\A]��I��H��?��ff.��f�UH��SH��H��H�~(H��tKH�v0H�L$H��Y��t&H�$H�T$H9�w�%D��H��H9�vH9hu�1�H��[]��H�{H��dU��tB��u�H�{H��U��t-��t�C8��u�H�S0H�{ H��?X��H��[]��ø��fD��AUATI��UH��SH��(H��[��H�D$H��I�\|$(H�L$H�T$H��X��H�\$H�D$H9��L�-��1��H�D$H��H9��H�sL9�t�I�D$ H�xH�@�PH��H��t1H�\|$H��T��tH�m�u�H��S��f�H��tH�m�t4H�\|$H��tH�/tE1�H��(L��[]A\A]��S��f��H��xS��fD��H�\|$��R��t�H�\$I�\|$8H��U��I��H��tI�E�H�\|$H�/u��2S��KV��H��u�I�\|$8H��H��vX��t�I��H�\|$�bR��u��D��AUH�w��ATUH��SH��H��xH�H�S(H�D$@H�C8�D$ ��H�\|$(H�t$8�D$H��H�T$XH�D$`�OY��H�D$PH��H�{ H�L$H�T$H��+W��2��L�l$H�T$L�d$ H�-��I9�s}��I�EH9�tdH�pH�{H�D$0H��H�W@H��%��H��H��u��@�H�@ H��H;0u�L��H��P��D$H��H�T$I��I9�r�H�\|$P�0Q��tkL�d$PH�{0L��S��H��t~H�\|$PH��H�/uSH�D$�Q��H�S(H�D$H�jH��x[]A\A]�@�蛢��L��H��P��u��f��H�\|$P1�H�/t�H�S(H�jH��x[]A\A]�H�-��RT��H��u�H�{0L��L��~V��t�L��\��AUATUSH��H��H�̾��H9FtH�G0H��H��[]A\A]��L�l$I��H� H��L��L��vU��}��H�$H;D$s"H�pH;5W��tRH�C(H�xH�@�P�@�H�{ �wW��H�s H�{�z��t5H�{ L��L��H��U��tH�$H;D$r�H�C8H��H��[]A\A]�1��K��f��UH��H��SH��H�}�H�L$H��T��t+H�$H;\$r�1�H��H9\$v%H�sH�}��P��u�H��[]��H��1�[]��ATI��H��UH��SH��I�<$H�L$H��NT��t2H�$H;\$r�<@�H��H9\$v-H�SI�\|$H��S��u�H��[]A\�f��H��1�[]A\�D��SH��H��H��H�;H�L$H��S��t H�T$1�H9$tH��[�D��C��H��[�fD��ATUSH�� H��0��1�H��H��H�L$H�T$H��mS��H�T$H�D$H)Ѐ{0��H�M��I��I��L;e��H��~V1��f�H��I9�~GH�T$H��H�L�H��H�H�xH�HH�BH��H��t�H�/u��3N��H��I9��f.��1�H�� []A\�D��H��u>H�zH�jH�E�H�/u��M��H�� 1�[]A\��H�t$�b��H�t$��H��H�5�4��H�8�N��H��H�5Y4��H�8�N��q��H�Ⱥ��H�5�4��H�8�iN��Q��ff.��@�ATUH��SH��H��1�t\H�L$H��H��H��Q��H�T$H�$I��I)Ā{0�t;H9��I��L�@I��H��L��[]A\�@��a��f��L��H��H��O��I��H��tSM��~�H�$1�fD��H��H��H�TH�I�T�H��H9��H��L��[]A\�fD��H��H��H�8�L��H��E1�[L��]A\��H��H�5C��H�8�:M��E1��B��f�AVAUATUH��SH�� H��H�\|$H�}H��D$��H�pH9�t �Q��tTH�T$H�5��H��N��D$��tH��H��H�� []A\A]A^��H�9��H�}H�5M��H9��Q��H�E��1�H�}�L�t$I��3��H�L$H��H9$��I�$H��H��H;]�S��H�EH�\|$L��L��L�$�I�$L��O��I�$u�H��I�$uL��J��H�� 1�[]A\A]A^�H�T$H�5��H��N��H��P��I��H��t�H�\$�L��K��H��H��H�\|$H��H��H��AO��H�E�thH�L$H��H9$tyH�E�H��u�H��hJ��fD��L��XJ��D$��I�$H��{��L��3J��D$�G��f.��H��H�E�uH��J��I�$��D��D$��H�E�H��uH��I��I�,$��L��H��t��ff.��AWAVAUATI��UH��SH��(H�\|$H��J��H�D$H��A�\|$1��<��H��H�}H��H�pH9��TO��H�}H�5��H9��3O��H�E��H�}��E1�L�\|$I��@�H�EH�\|$L��L��N�$�I�$L��M��T��H�$H;\$r�W��H��H;\$�A��H�sH�\|$�I��u�I�,$uL��H��H�\|$H�/u�H��H��(1�[]A\A]A^A_�fD��H�T$H�5<��H��TK��t�H�D$H��([]A\A]A^A_��L��]��H�T$H�5��H��4L��H��jM��I��H��o��L�l$f��L��HH��H��H��H�\|$H��L��H��L��t2H�$H;\$r�g��H��H;\$sUH�sH�\|$�H��u�H�m�uH��G��I�,$��I�,$t[I��L;m�[��fD��H�m��U��H��MG��H��[J��H��u�I�,$��L��#G��L��G��@�AWAVAUATUH��SH��(H�\|$�K��H�D$H��H�X��H�}H��H�pH9��L��H�}H�5\��H9��L��H�E��H�}��E1�L�t$I��H�EH�\|$L��L��N�<�I�L��K��H�$H;\$r�X��H��H;\$�A��H�SH�\|$L��I��u�I�/u L��E��D��H�\|$H�/t[1�H��([]A\A]A^A_�@�H�T$H�5��H��H��t�H�D$H��([]A\A]A^A_��H�T$H�5��H��I��E��1��H��J��I��H��t�L�l$@�L��E��H��H��H�\|$H��L��H��I��t5H�$H;\$r��H��H;\$smH�SH�\|$H��H��u�H�m�uH��E��I�,$��L��D��I�/uL��D��I��L;e�T��H�m��=��H��D��0��G��H��u�I�,$��L��D��I�/�\|��j��ff.��@�AWAVAUI��ATUH��SH��H��H�}H��H�pH9�t � J��t$H��L��H��[H�5��]A\A]A^A_�F��@�H�}H�5��H9��I��A�ƅ��H�E��1�H�}�"�@��D��A��+��H��H;]�#��H�EL�$�I�D$I�$��I�\|$��I�T$ I�t$L��E1��G��A��A��I�,$u�L��OC��D��H��L��H��[H�5�]A\A]A^A_�8G��H��hH��I��H��u ��tiL��KC��H��H��H�@��toH�}uhH�U H�uL��1��iF��H�m�u�H��B��H��H�5")��H�8�C��I�,$uL��B��A��H��D��[]A\A]A^A_�H��H�5�(��H�8�MC��H�m�u�H��NB��gE��H��u�I�,$u�L��3B��묐AT1�I��H� ��H��H��H��8��H��L�L$I��H�$��H�D$��SF��tfL��wC��I��H��tVH�\|$H��t�E��tA�D$0H�4$H��tH;5f��t L��<F��tH��L��A\�D��I�,$uL��A��E1�H��L��A\�ff.��H��E��tH��H��H��f�1��ff.��ATUH��H��E��H��t+H��H��I��E��tH��L��]A\�fD��I�,$tE1�H��L��]A\��L��@��fD��F��ff.��AT�F��H��t#H��I��B��tL��A\�fD��I�,$tE1�L��A\��L��@��fD��{B��ff.��ATUH��H��!F��H��t+H��H��I��D��tH��L��]A\�fD��I�,$tE1�H��L��]A\��L��@��fD��H�=��A��@�AUATUH��SH��(H�<$�>��H�D$H��H�M��H�}H��H�pH9�t �E��ttH��H�52��H��B��t5H�D$H��([]A\A]�H��I�E�uL��?��I�,$uL��t?��@�H�\|$H��t H�/��1�H��([]A\A]��H�}H�5��H9��E��H�E��1�H�}�"�c��I�,$toH��H;]�F��H�EL�$�H�$H�xH�@L��I�$�PI��H��=��H�\|$L��H��PB��I�E��H��I�E�u�L��>��I�,$u�L��>��{>��1��@�H��H�5��H��nB��f��H��C��I��H��@�L��>��H��H��tbH�$H��H�xH�@�PI��H��t\|H�\|$H��H��A��I�$tQH��I�$tH�m�u�H��=��f.��L��=��@��H��u9I�m��L��=��H��I�$uL��=��H�m�uH��=��I�m��L��p=��ff.��1��ff.��f�AWAVAUATUSH��H��L�%,��H�=��L�`H��H��8��H��>��`��L�-I��I��8��L��>��;��L�5\|��I��8��L��>��L�=��I��8��L��>��H��H��8��\|��H��d>��H�u��H��8��o��H�=`��;>��H�=T��H��8��^��>��I��$8��Z��L��=��b��H�=V��!?��I��H��E��H�V��H�8��4��L��L�D$�B��L��H�536��H��H��:��H��H�56��H��:��L��H�5q2��H��~:��H��H�5�5��H��h:��L��H�5�5��H��V:��H��H�5.��H��@:��H�552��L��H��.:��H�="0��r@��H��H��A��^:��L�D$��H�52��1�L�D$�?��H�52��1��?��H�52��1�H��?��H�52��1�H��?��L�D$H�q��H��L��[]A\A]A^A_��H��(��H�=@"��H��@��=��I��H��o��E1��f.��H��H��8��@��D��H��I��8��J��D��H�q��I��8��W��D��H�Y��I��8��d��D��H�A��H��8��q��D��H��H�&��H��8��{��f�H��H��8��D��H��I��$8��@�1�H�='!��L�D$�];��H� ��L�D$H��H��D��(��H�ħ��H�=!��L�D$H��{?��f<��L�D$H��u H�5��H�5p0��L�D$H�8�:��L�D$I�(��L�� 9��D��H��H�540��L�D$H�8��9��L�D$�"��f.��ATUSH�_H�o L�gH��H��t L��Յ��H�{H��t L��Յ��H�{ H��t L��Յ��H�{(H��t L��Յ��H�{`H��t L��Յ��H�{hH��t L��Յ�umH�{pH��t L��Յ�u[H�{xH��t L��Յ�uIH��H��t L��Յ�u4H��H��t L��Յ�uH��1�H��t[L��H��]A\��D��[]A\�ff.��ATUSH�_H�o L�gH��H��t L��Յ��H��`��H��t L��Յ�u\|H��X��H��t L��Յ�ugH��P��H��t L��Յ�uRH��H��t L��Յ�u=H��h��H��t L��Յ�u(��tH��X��H��t[L��H��]A\��D��1�[]A\ÐATI��USH�_H�GH9��H9�`��H9�X��H9�P��%��H9��H9�h��;��1��tI�L$H9�X��t []A\�D��H�=�X��I�\$ �;��L��H��Ӆ��H�o H�=���;��L��H��Յ��I�D$H9�`��B��f��H�=PX��I�l$ �?;��L��H��Յ��I�D$H9�X��H�=X��I�l$ �:��L��H��Յ�ulI�D$H9�P��@�H�=�W��I�l$ ��:��L��H��Յ�u4I�D$��@�H�=�W��I�l$ �:��L��H��Յ��[��]A\��H�=�W��I�l$ �_:��L��H��Յ�u�I�D$�T��@�ATI��USH�_H�GH9��H9C� ��H9C �8��H9C(�f��H9C`��H9Ch��H9Cp��H9Cx��H9��!��H9��tE1�H9��t<[D��]A\�@�H�=W��I�l$ �9��L��H��Յ�u>I�D$��H�=W��I�\$ �o9��L��H��E1��A��A��[]D��A\�f�H�o H�=iV��09��L��H��Յ�u�I�D$H9C��H�=EV��I�l$ �8��L��H��Յ�u�I�D$H9C ��H�=V��I�l$ ��8��L��H��Յ��b��I�D$H9C(��H�=�U��I�l$ �8��L��H��Յ����I�D$�j��H�=pU��I�l$ �_8��L��H��Յ��I�D$�D��H�=@U��I�l$ �/8��L��H��Յ��I�D$��H�=jU��I�l$ �7��L��H��Յ��I�D$��H�=FU��I�l$ ��7��L��H��Յ��j��I�D$��H�=U��I�l$ �7��L��H��Յ��:��I�D$��AWAVAUATUH��SH��H�_L�{H��M�g �7��I��H9E�>��M��tI�m��v��H�EH9C�~��I9��I9G ��I9G�S��I9G�y��I9G��H9C ��IcD$L1ۅ�2��D��A��@uE��yI�D�HH�MH9Ht^IcD$LH��H9�~uI�D$hD�t I�D$`L�l�H�EI9D�Hu�I�E�H��L��U ��t�H��[]A\A]A^A_�D��I�E�H��L��U ��u�IcD$LH��H9��I�WHL�,�IcG@L��L�$�M9�r�Mf��H��I9�v;H�EH9u�H��L�u L)�H��{2��H��H��A�օ��d��H��I9�w�H��1�[]A\A]A^A_��L��0��H�EH9C��H�=HS��L�m �5��H��H��A�Յ��H�EI9�X��H�=S��L�m �h5��H��H��A�Յ��H�EI9G �'��@�H�=�R��L�m �05��H��H��A�Յ��H�E��H�=�R��L�u ��5��H��H��A�օ��M��`��I�m��U��L��/��H��f��H�=kR��L�m �4��H��H��A�Յ��H�E�~��H�=FR��L�m �4��H��H��A�Յ��H�E�X��H�= R��L�m �P4��H��H��A�Յ��H�E�2��H�=�Q��H�] � 4��H��H��Ӆ��fD��AWAVAUATUS1�H��H�WL�o H�\|$L�wH�jH�$L�} A�OL��Vf��9�}FI�GhLc�B�D t�I�G`J�\|��L3�� H�=;#��H��A�OL��9�\|�H�<$�3��I��H��tL��H��A�Յ��I�,$��H�$H�x H��tL��A�Յ��H�}�H��t L��A�Յ�u\|H�} H��t L��A�Յ�uiH�}H��t L��A�Յ�uVH�}H��t L��A�Յ�uCH�}H��t L��A�Յ�u0A�WL1ۅ�~$f�Hc�H�\|�HH��tL��A�Յ�u A�WL��9�\|�1�H��[]A\A]A^A_�D��H�D$H�@(J9D�H��1��L��(-��ATUH��SH��3��H��~EI��1�� @�H��I9�t1H�}H��.��H9Eu�H��.��H��H��tH��U ��t�[1�]A\�[��]A\�D��ATUH��SH��1��H��~EI��1�� @�H��I9�t1H�EH�@H��H9Eu�H��-.��H��H��tH��U ��t�[1�]A\�[��]A\�D��USH��H��H��H�oH�0H��a.��H9C(t#H�EH�SH�s H�{H��H��[]��@�H��1�[]�ff.��@�ATI��USH�_H�GH9CtE1�H9C tG[D��]A\�f.��H�o H�=�N��0��L��H��A��u�I�D$E1�H9C u�H�=�N��I�\$ �0��L��H��E1�[]��A\A��D��ff.��H�WH�OH9Jt 1��ATI��SH��H�_ H�=?N��N0��L��H��Ӆ��H��[A\ÐATI��USH�_H�GH9CtE1�H9CtG[D��]A\�f.��H�o H�=�M��/��L��H��A��u�I�D$E1�H9Cu�H�=�M��I�\$ �/��L��H��E1�[]��A\A��D��ff.��ATI��UH��H��/��H��H��H��x��H��H��t"I9\|$tAH�/u����H��V��H��H��u�H�m�tW�-��H��H��]A\��1�I�l$ �+��L�� H��H��]A\�f�H��]A\��H��)��fD��AWAVAUATUSH��8�T$�L$H�D$(��H��t^H��I��L�\|$ 1�L�t$L�l$(��H��L��L��L��L��.��t)H�CH;D$t4H9D$ u�H�t$�\|$H��H��S ��t�H��81�[]A\A]A^A_�D��H�K H��H�$���\|$H�$H��H��х�u�H�C�ff.��ATUH��SH�_H�sH;wt[H��]��A\�+��D��L�g H�=B��-��H��H��A�ԅ�uH�s��[��]A\�fD��ATUH��SH��.��I��H9Et[L��H��]��A\�.+��fD��H�=��H�] �H-��H��H��Ӆ�t�[��]A\�ff.��f�ATUH��SH�_H�GH9C0��H9C��H9Ch�+��H9C8�Y��H9C@��H9CP��H9C ��H9CX��H9CH��H9CptQH9C(tH�sXH��[��]��A\�a��H�=�J��L�e �,��H��H��A�ԅ�t�[��]A\�@�H�=�J��L�e �P,��H��H��A�ԅ�u�H�E��L�g H�=0J�� ,��H��H��A�ԅ�u�H�EH9C��H�= J��L�e ��+��H��H��A�ԅ��l��H�EH9Ch��@�H�=�I��L�e �+��H��H��A�ԅ��4��H�EH9C8��@�H�=�I��L�e �+��H��H��A�ԅ��H�E�x��H�=�I��L�e �P+��H��H��A�ԅ��H�E�R��H�=eI��L�e � +��H��H��A�ԅ��H�E�,��H�==I��L�e ����H��H��A�ԅ��l��H�E��H�=��L�e ���H��H��A�ԅ��<��H�E��H�=�H��L�e ���H��H��A�ԅ��H�E��H�w��-(��ff.��f�USH��H��H�̒��H�CH�I��H�CHH�֑��H��H� ��H��H��H��H�\|��H��H��H��H��H��H��H��H��H��H��H��H��H��H�ȑ��H��H��H��)��H��t+H��H��#��H��H��tH�@H��H��H�/t%H�m�tH��[]��H��H��[]�$��f��#��H�m�u��H��H��conf_relate_visit: invalid relation type��nodegraph changed size during iteration�cli_and_memoized_kind: argument must be a (subtype of) tuple.��cli_and_memoized_kind: wrong length of argument.��horizon_remove: no such horizon found��====================================================================== �Output from _PyObject_DebugMallocStats() ��Total reference count = %12zd ��set_limitframe: frame or None expected��delete_extra_type: argument must be a weak ref, got '%.50s'��delete_extra_type: reference object %p not found��Duplicate heap definition for type '%.50s'��no such interpreter state number��thread state has no frame numbered %d from bottom��thread state has no attribute '%s'��interpreter state has no attribute '%s'�root state has no attribute %R��Getting thread state without an interpreter number is deprecated. Use %R instead��inrel_visit_memoize_relation: can only memoize relation (not "%.200s")��horizon_patched_dealloc: could not clear object in nodeset��horizon_get_org_dealloc: no original destructor found��register_hidden_exact_type: type is already registered��register__hiding_tag__type: type has no '_hiding_tag_' slot��register__hiding_tag__type: type is already registered��heapdefs must be a capsule object��heapdefs must be named <package name>._NyHeapDefs_��rel_new: Invalid relation kind: %d, must be > 0 and < %d.��hv_cli_rcs_memoized_kind: nodeset object (immutable) expected.��Invalid cmp argument to NyNyObjectClassifier_Compare��Compare argument must be a string.��Compare argument must be one of < <= == != > >=�Invalid value of cmp argument.��This classifier supports only equality selection.��Unable to determine sizeof(PyGC_Head) from _testinternalcapi.SIZEOF_PYGC_HEAD, assuming %zd��Tuple of triples with [0] a CLASSIFIER expected.��Tuple of triples with [2] a STRING expected.��cli_and: classifiers argument must contain classifier objects.��O!:update_referrers_completely��update: right argument must be sequence of 2-tuples��Item deletion is not implemented for nodegraphs.��ng_ass_sub: can not change number of edges (wants to always be fast); consider using .add_edge() etc. instead.��ng_ass_sub: value to assign must be a tuple��guppy.sets.setsc.NyNodeSet_Exports��Error at initialization of module heapyc��__dir__($self, /) -- Specialized __dir__ implementation for rootstate.�The hiding tag: if it is the the same object as the hiding tag of a HeapView object, the nodegraph will be hidden from that view.��NG.is_mapping : boolean kind, read only True if NG is a 'mapping'. Then, only one edge is allowed for each source; indexing returns the actual target object instead of a tuple of targets.��NG.is_sorted : boolean kind, read only True if NG is sorted. It will become unsorted after any update. It will need to be sorted to make it possible to find edges (implementation uses binary search). Any indexing operation will automatically sort it if it was not already sorted. The flag is currently used from Python to see if the nodegraph has been used at least once after update, so that it will not be cleared too early.��HV._hiding_tag_ The hiding tag defining what objects are hidden from the view defined by HV. Objects that contain a _hiding_tag_ object which is identical to HV._hiding_tag_, will be hidden from view, in the following cases: o The object is of a type that has been registered for hiding via _hiding_tag, or is of a subtype of such a type. o The object is of instance type. Such an object will be checked for a _hiding_tag_ item in its __dict__. ��HV.is_hiding_calling_interpreter : boolean kind If True, the data of the interpreter using the HV will be hidden from the heap view as seen from RootState. This is used when multiple Python interpreters are used. One interpreter will be monitoring the operation of the other interpreter(s). It would set is_hiding_calling_interpreter to True in the HV it is using. Its own data will then be hidden from view, making memory leak detection more practical.�HV.root An object that is used as the starting point when traversing the heap. It is normally set to the special RootState object, which has special functionality for finding the objects in the internals of the Python interpreter structures. It can be set to any other object, especially for test purposes. See also: RootState��HV.static_types : NodeSet, read only The 'static types' that have been found. The static types are the type objects that are not heap allocated, but are defined directly in C code. HeapView searches for these among all reachable objects (at a suitable time or as needed).��classifier returning object type��classifier returning index of matching kind��classifier returning object size��classifier returning object producer��classifier returning singleton set containing object itself��classifier returning the object itself��classifier based on a combination of other subclassifiers��guppy.heapy.heapyc.RootStateType��guppy.heapy.heapyc.ObjectClassifier�RootState�edges[%d].src�edges[%d].tgt�modules�i%d_%s�modules_by_index�sysdict�importlib�codec_search_path�codec_search_cache�codec_error_registry�builtins_copy�import_func�before_forkers�after_forkers_parent�after_forkers_child�audit_hooks�c_profileobj�i%d_t%lu_%s�i%d_t%lu_f%d�c_traceobj�curexc_type�curexc_value�curexc_traceback�async_exc�async_gen_firstiter�async_gen_finalizer�context�Output from malloc_stats �Other statistics �__dict__�i%d_%n�t%lu_%n�f%d%n�no such thread state number�i%d_%U�gc�get_objects�O!:register_hiding_type�OO:numedges�_hiding_tag_�OO:relate�ob_type�O!O!O!\|O!i:shpathstep�O!O!:reachable�pop from empty list�delete_extra_type�._NyHeapDefs_�OO!:hv_new�iO:rel_new�O:partition�O:Horizon.__new__�<�OOO:select�O!OOO:user_defined�O!O!O!:cli_rcs�O!:cli_prod�hexversion�_testinternalcapi�SIZEOF_PYGC_HEAD�O!O!O!:cli_inrel�O!:cli_indisize�O!O!:cli_findex�Tuple of TUPLES expected.�Tuple of TRIPLES expected.�O!O!OO:cli_dictof�O!O!:cli_and�O!:update_dictowners�O!O!:update_referrers�OO:�Ambiguos mapping�\|OO:NodeGraph.__new__�ObjectClassifier�RootStateType�malloc_usable_size�malloc_stats�_PyObject_DebugMallocStats�_Py_RefTotal�module initialization failed�X�relator�iterable�is_mapping�cond_cli�cond_kind�classify�memoized_kind�start�avoid�G�S�AvoidEdges�find_one�root�heapdefs�heapyc�xmemstats�__dir__�is_sorted�add_edge�add_edges_n1�as_flat_list�clear�domain_covers�domain_restricted�get_domain�get_range�invert�inverted�relimg�update�updated�nodegraph-iterator�news�self�epartition�<=�==�!=�>�>=�limitframe�is_hiding_calling_interpreter�static_types�cli_id�cli_idset�cli_none�cli_type�cli_user_defined�indisize_sum�heap�reachable_x�register_hidden_exact_type�register__hiding_tag__type�update_referrers_completely�classifier returning None�user defined classifier�hv_cli_rcs�classifier returning ...�hv_cli_prod�guppy.heapy.heapyc.NodeTuple�guppy.heapy.heapyc.Relation�guppy.heapy.heapyc.NodeGraph�guppy.heapy.heapyc.Horizon�guppy.heapy.heapyc.HeapView��9��9��9��9��9��9��>��=��=��=��=��>��ň��horizon_get_org_dealloc��horizon_patched_dealloc�horizon_remove��HV.update_referrers_completely(X:nodegraph) Update referrer graph X 'completely'. [Experimental algorithm that updates X with the referrers to all objects in the heap (of visible nodes as defined in HV). It is not normally used.]��HV.update_referrers(X:NodeGraph, Y:NodeSet) Update referrer graph X for Y. The visible heap defined by HV will be traversed from the root of HV so that the edges of every path from the root to nodes in Y will be represented, inverted, in X.��HV.update_dictowners(owners:NodeGraph) Update owners with ownership edges. The dict owners graph will be updated with an edge from each dict object in the heap, to either its owner or to None.��HV.limitframe : frame \| None The traversal limiting frame. If limitframe is set to a frame object, the frames that are more recently entered than limitframe will be hidden when traversing the heap from the root RootState. It will start traversing from limitframe rather than from the most recent frame as it would otherwise do.��HV.shpathstep(G:NodeGraph, U:NodeSet, S:NodeSet [,AvoidEdges:NodeGraph [,find_one:bool]]) -> NodeSet This method implements one step of a shortest path algorithm. The arguments are: G Updated by the method, with the edges from nodes in the source set to the new nodes visited. U The source set for this step. S The set of already visited nodes. AvoidEdges Edges to avoid. find_one If True, at most one edge will be found from each node in the source set. Normally, all edges will be found. Return value: The new nodes visited. This may be used for the U argument the next time the method is called. See also: shpgraph_algorithm in Path.py.��HV.relimg(S:iterable) -> NodeSet Return the 'relational image of HV wrt S'. That is, the set of nodes that are directly referred to from the nodes in S via the visible heap reachability relation as defined by HV.��HV.relate(src, tgt) -> relation structure Return a description of the relation between src and tgt. This is used for descriptions of edges in paths. [The result is in a special format that I choose to not define here since it is for special low-level use and subject to change.]��HV.register_hidden_exact_type(type) Register a type of objects that should be hidden from the heap view defined by HV. Objects of the exact type registered -- not including subtypes -- will be hidden. See also: register__hiding_tag__type.��HV.register__hiding_tag__type(type) Register a type of objects that may be hidden from the heap view defined by HV. The type must have a slot named _hiding_tag_. An object that is an instance of the type, or of a subtype, is hidden when its _hiding_tag_ is HV._hiding_tag_.��HV.reachable_x(X:NodeSet, Y:NodeSet) -> NodeSet Return the set of objects reached via a path in the visible heap as defined by HV, from some object in X, avoiding any object in Y except at the end of the path.��HV.reachable(X:NodeSet, Y:NodeSet) -> NodeSet Return the set of objects reached via a path in the visible heap as defined by HV, from some object in X, avoiding any object in Y.��HV.numedges(src, tgt) -> int Return the number of edges from src to tgt.��HV.indisize_sum(S:iterable) -> int Return the sum of the 'individual size' of the objects in S. See also HeapView.__doc.��HV.heap() -> NodeSet Return a set containing all 'visible objects' in the heap view defined by HV. See also HeapView.__doc__.��HV.cli_type() -> ObjectClassifier Return a classifier that classifies by type. The classification of each object is the type, as given by its C-level member 'ob_type'. (This is the same as the type returned by the Python-level builtin 'type'.)��HV.cli_none() -> ObjectClassifier Return a classifier that classifies all objects the same. The classification of each object is None.� ��HV.cli_inrel(referrers, memo) -> ObjectClassifier Return a classifier that classifes by "incoming relations". The classification of an object is the set of incoming relations. referrers A NodeGraph object used to map each object to its referrers. memo A dict object used to memoize the classification sets. ��HV.cli_findex(tuple, memo) -> ObjectClassifier ��HV.cli_rcs(referrers, classifier, memo) -> ObjectClassifier Return a classifier that classifies by "Referrer Classification Set". The classification of an object is the classifications of its referrers, collected in an immutable NodeSet object. Arguments: referrers A NodeGraph object used to map each object to its referrers. classifier A ObjectClassifier object used to classify each referrer. memo A dict object used to memoize the classification sets. ��HV.cli_prod(memo) -> ObjectClassifier Return a classifier that classifes by "producer". The classification of an object is the file name and line number in which the object is produced (allocated). memo A dict object used to memoize the classification sets. ��HV.cli_id() -> ObjectClassifier Return a classifier that classifies by set of identity. The classification of an object is a singleton immnodeset containing the object itself.��HV.cli_id() -> ObjectClassifier Return a classifier that classifies by identity. The classification of an object is the object itself.��HV.cli_dictof(owners, ownerclassifier, notdictkind, notownedkind) -> ObjectClassifier Return a classifier, that classifies by "Dict Owner". The classification of an object is the notdictkind, unless the object is a dict object. If the dict is 'owned' by some owner, the classification will be the class (as by the ownerclass argument ) of its owner. If it is not owned, the returned kind will be notowned argument. Arguments: owners A NodeGraph object used to map each dict object to its owner, or to None if it has no owner. The graph will be automatically updated, from heap information defined by HV, whenever an attempt is made to classify a dict that maps to nothing. ownerclassifier notdictkind notownedkind ��Tuple with comparison based on addresses on the elements. ��HV.cli_and(classifiers, memo) -> ObjectClassifier Return a classifier that combines the classifications of other classifiers. The classification returned from the returned classifier is a tuple containing the classifications from the classifiers in the classifiers argument. ��HV.delete_extra_type(weakref) Delete extra type information. For internal use as a weak-ref callback.��HeapView(root, heapdefs:tuple) Create a new HeapView object with arguments: root The initial value of the root member. heapdefs Definitions of specially treated extension types. A HeapView object provides methods to get memory related information about the system heap and about individual objects. It implements much of the low-level functionality for the Heapy system. It is intended to provide what can not be done at all or would be much slower if programmed directly in Python. It is not intended to be used directly by a user, but to be wrapped in higher level objects. Some terms that are referred to in the method descriptions: Visible objects. The HeapView object attempts to restrict its view of the heap to only the 'visible objects'. This is to make it possible to analyse the heap via a Python library that inevitably itself is continually allocating and deallocating objects. These should be hidden from the heap view presented. This is primarily done via a special tag attribute, see '_hiding_tag_' and 'register__hiding_tag__type'. Frames can be hidden with another mechanism, see 'limitframe'. For hiding all objects of a special type, 'register_hidden_exact_type' may be used. It is also possible to use a separate interpreter and hide its root objects, see 'is_hiding_calling_interpreter'. Classifiers. The methods named cli_ are factory methods that create objects of type ObjectClassifier. The principal difference between classifiers is how a single object is classified. The single-object classification function is available in classifier objects; it is the classify method. There are also methods that operate on collections of objects, namely partition and select. These eliminate the per-object Python-level function call overhead that would occur if the classify method were to be called from Python for each object in a collection. See also the ObjectClassifier type. Individual size. The individual size of an object is its individually allocated memory size. It includes: o The basic object size, as can be found out in a standard way. o The extra memory for variable size objects. o For GC collected objects, the size of the GC information. o An alignment to the next highest multiple of a pointer size. o The size of any other memory allocated that belongs to the object. Some types of objects have extra memory allocated that can not be accounted for in the standard way. This memory should nevertheless be included in the individual size. To determine the size of these objects, special functions are needed. These are defined for standard builtin types, such as lists and dicts. Other types should be defined via the heapdefs argument to the HeapView constructor. The individual size does not include: o Subobjects that are accounted for separately. o Overhead for the memory allocation system. This varies depending on the kind of memory allocator, the requested size, etc. �newname�__mro__�__bases__�__base__�__slots__�co_code�co_consts�co_names�co_exceptiontable�co_filename�co_name�co_qualname�co_linetable�co_weakreflist�f_back�f_func�f_code�f_builtins�f_globals�f_locals�f_trace�__self__�__module__�cell_contents�tb_next�tb_frame�__code__�__globals__�__defaults__�__kwdefaults__�__doc__�__name__�__closure__�__annotations__�__qualname__��;�� H�L��N��U��(�H��8�\��H�p��X��h��x��(��X��h�$��x�8��L��`��t��(��H��h��L ��` ��X�t ��h�� x�� h�T �� h��(�X��8�l��h��H��X��0��h�\��h� ��8�h �� H��`��h ��H��@��x��T��(��X��@��,��d��<��P��d��x��8��p��H!��"��"��"��$��"��8��"��L��#��d��#��h$��$��h%��D��%��&��'��('��'��4��(��H��X(��(��)��)��)��P����d����x��(��8����8+�� (,��p��,��,��H-��h-��.��<��8/��h��0��0��1�� 2��p��X4��7��8��H��8��\��9��<��?��T��@��@��xA��hD��X��D��(E��E��E��F��0��I��\|��hN��P��R��d��(U��hW�� Y��p ��[�� x_��$!��(`��<!��`��t!��b��!��b��"��e��l"��f��"��f��"��f��"��g��@#��i��#��i��#��j��#��k��8$��k��L$��k��`$��(n��$��o��%��p��4%��p��l%��p��%��Xs��%��xs��%��t��D&��u��&��Hv��&��y��'��hy��4'��8��'��'��'��(��'��(��D(��(��(��x��(��(��)��`)��ȇ��)��X��)��8��$��t������X��+��T+��+��,��8��h,��,��H-��ؚ��t-��-��h��-��x��-��ț��.��؛��.��8��L.��H��`.��.��.��x��/��H/��H��/��H��/��/��\0��(��0��0��1��h��L1��1��X��1��1��(2��t2��2��h��2�� 3��8��43��zR�x��$��`��FJw��?;3$"��D��X�� l��V��(�� $��(��@�� <�� 4��8��H��D��\��@��p��<�� 8��D��P��\��h��\��t��B�E�B �D(�D0�F (A BBBBJ (D EBBIA(C BBB��H��\��3��p��1��A�] BP��1��A�] BP�(��B�D�D �z ABIH��B�B�A �F(�D0k (D ABBEO(D ABB��\��P��B�E�A �A(�G0R (D ABBEL (D ABBK@ (D ABBG��6��A�[ LI�@��B�A�G p DBHw DBEA ABA��<��H��B�A�G H DBHR ABKtAB��T��h��,��B�i��$��S�X E_ AP��`�-��\|��(��x�S��B�A�D �] ABI(��I��B�A�D �] ABI(��,��S��B�A�D �] ABIH��X��B�B�B �B(�A0�A8�D@� 8D0A(B BBBF�8��H��B�B�A �D(�DP^ (A ABBG�8��,�G��B�U�B �A(�D0�\| (I BBBGD��@��B�B�B �B(�A0�A8�D@�8C0A(B BBBH��d��p��B�B�B �B(�A0�A8�DPN 8A0A(B BBBJ�H��B�D�B �B(�A0�A8�D`w 8D0A(B BBBD�H�� B�B�B �B(�A0�A8�G`� 8A0A(B BBBE��H��A��\��1��A�` GH�8��\|��o��B�E�D �D(�G`E (A ABBG�(��4��e��B�A�G DBA��x��I��8��\|��B�B�B �D(�D0��(A BBB��<����L��P��B�B�D �D(�G0k (A ABBD� (A ABBA��zR�x�0��$��.��LQ��0��w��Ds I��0�� B�H�G N DBKoAE`��< ��B�B�B �B(�A0�D8�GP� 8F0A(B BBBEF 8A0A(B BBBH\�� L��B�B�D �D(�G0k (A ABBDZ (A ABBA[ (D ABBK��d��I�� 4��( ��A�D�G x AAJ] FCJ��4��` ��<��A�D�G AACl CAH�8�� $��B�E�A �D(�P0H (D ABBC�� #��L�� B�B�A �D(�D0o (A ABBFz (A DBBA��8��L��`��H��t��B�B�B �E(�A0�A8�DP� 8D0A(B BBBD�H��L��B�B�E �A(�D0�f (F BBBHE(D BFB\��u��B�B�A �A(�G0� (D ABBDq (D ABBFd (D ABBK�H��l��B�B�B �B(�D0�G8�D`� 8D0A(B BBBH�<�� [��R�S�B �A(�A0�H (A BBBH�� 4 �� H ��"��GU�4��` ��B�G�D G DBAV DBI�4�� A�D�G E AAEd FAE�4�� s��B�A�D �U ABAOAB��4��s��B�A�D �T ABBOAB��<��@��b��A�D�G X AAJ\ AABHDA�L��L�� B�B�A �A(�G0� (D ABBFK (E AHBE��/��(�� 4��$��A�D�D i DAIT DAB��0�� 4��D��P��B�A�D �c ABCXAB��@��\|��X��B�D�D �W ABDU AEEHAB��0��N��A�D�G ] AAEVDA�� @��B�M�E �D@� DABH\ DABA��L�� `�� t�� <��v��B�H�D s DBIL DBFGDB�<��z��G�B�E �D(�A0�W�(D� B�B�B��L��B�F�B �B(�A0�{ (D BBBFI (D BBBE�<��l��B�A�G r ABIu DBMDAB��S��h�� L��t��h��B�A�D �D0� DABJv KABDx DAB��(��8��_��A�D�G @ CAH�@��d��B�B�D �e BBGg DBKFOB��D��T��B�A�D �q ABE\ ABAD AEF��(��A�] � AAZ CKL��B�D�A �N(�DP� (A ABBET (C ABBD��4��l��`��A�M�Q0� CAB� AAHT��w��B�M�N �G�� DABF� DABE� GABG��D��B�B�D �� BBGA DBIV OBI��D�� D��X��A�TXl`FhBpFxA�F�H�PPM ADT CI�T��L��B�I�B �B(�J0�H8�DpWxD�Mp� 8A0A(B BBBH��T�� B�I�B �B(�J0�H8�DpWxD�Mp� 8A0A(B BBBH��@��P��\|#��B�D�D �x DBH\ AFMFAB��0��$��F��A�D�J P AAGVDA�<��$$��r��A�D�J _ AAH\ AAJHDA�H��d$��B�B�E �B(�A0�A8�L@� 8D0A(B BBBC�$��T��'��j��A�[(_0P(C ZA(��\|��P'��A��A�H�G _ AAG��0��t'��A�] p AAD CIcC��'��8��'��B�E�A �D(�G0O (A ABBH�H��,��(��B�B�B �B(�A0�A8�Dp� 8D0A(B BBBDH��x��4+��B�B�B �B(�D0�A8�D`� 8A0A(B BBBA@��/��A��B�A�D �D0Y DABE� GABA�T��1��B�B�B �A(�D0�D@� 0A(A BBBAs 0C(A BBBG`��`��L3��j��B�B�B �B(�A0�D8�G`< 8A0A(B BBBFa 8A0A(B BBBEL��X5��4��B�B�A �D(�D@[ (A ABBB� (A ABBD��T��H7��(��B�D�B �A(�A0�Q`q 0A(A BBBA{ 0C(A BBBF@��l�� 9��B�K�B �J(�H0�D@� 0D(A BBBG�l��:��B�B�B �A(�D0�G@[ 0D(A BBBH\ 0D(A BBBAe 0D(A BBBH�� L>��}_4��8��>��B�D�A � CBEi FBGH��p��L?��M��B�E�B �B(�A0�A8�DP� 8D0A(B BBBA�L��P@��B�B�A �A(�D0O (D ABBF` (D ABBA��X��@��B�D�B �A(�A0�Q`~ 0A(A BBBGZ 0C(A BBBD��(��h��DC��E��B�A�K �sAB��@��hC��A�XxM�F�F�Ppd AID CIVA��D��L��D��A�A�QpYxH�KxApn AAHD CAHVAA��P��<��D��B�C�A �Q@l AABI� CABFV AABF��LF��L��HF��A�A�QpYxD�KxAp} AAEK CAAVAA��<��F��A�C�Q@V AACD CAHVAA��4��HG��H��DG��X��\��@G��u��B�N�B �A(�A0�D�� 0A(A BBBEJ 0C(A BBBD��L��dI��A�A�QpYxF�MxApl AABD CAHVAA��$��I��A�M�D`�AA4��0��J��B�F�A �A(�D0g(D ABB��h��4K��4��A�` GK�L��TK��p��B�B�B �B(�N0�A8�D�� 8D0A(B BBBH��tM��DT�L��\|M��-��B�B�A �D(�D0� (D ABBID (A ABBF��8��@��\N��B�E�D �D(�D0l (A ABBK�8��\|��@O��B�D�A �L ABAV ABH��L��O��B�F�B �B(�A0�A8�G�� 8D0A(B BBBK��$�� Q��X��A�S v AEDCL��0 ��,R��B�B�B �B(�D0�N8�D�e 8D0A(B BBBH��4�� Y��T��B�D�D �V ABE` ABA$�� Y��X��A�S v AEDC�� Z��&��GY�� $Z��]��Dv F��(��!��hZ��`��Q�D�G [ AAG��L��@!��Z��B�J�H �A(�DPe (A ABBAe (C ABBF��!��L\��/��Dj� ��!��d\��Y��A�G y AF��!��\��1��!��\��$��DY C��\��!��\��B�E�D �D(�G0� (A ABBFN (A ABBD^ (A ABBD�4��\"��]��A�D�G0I AAIK DAC8��"��(^��B�B�D �D(�DP� (D ABBD�L��"��\|_��B�I�A �D(�G�N (A ABBEy (A ABBA�L�� #��a��B�B�A �A(�G@Y (A ABBD� (A ABBA��0��p#��a��i��A�G�D0E FAHDCA<��#��a��{��B�G�D �D0L FABJD CAB�$��#��b��J��A�J f AFKF@��$��@b��B�A�A �D@� AABFb CABH��P��P$��c��B�A�D �G0V DABEZ DABGV DDBH��X��$��Xd��r��B�B�B �A(�D0�DPa 0A(A BBBH� 0C(A BBBA��`��%��\|f��B�B�B �B(�D0�D8�D`! 8C0A(B BBBGb 8A0A(B BBBD`��d%��h��B�B�B �B(�A0�D8�D` 8A0A(B BBBEb 8A0A(B BBBDx��%��k��/��B�B�B �E(�A0�D8�D@d 8G0H(B BBBI� 8G0H(B BBBM� 8D0A(B BBBA(��D&��l��B�] n EFVE��p&��\m��$��DY C��4��&��pm��Z��B�A�G a DBGN DBD��&��m�� &��m��J��B�_ GO I��&��m��4��'��m��Z��B�A�G a DBGN DBD��H'��m��L��\'��m��B�B�A �D(�DPW (A ABBA (A ABBH��'��0p��H��'��,p��u��B�B�B �B(�A0�A8�DP� 8D0A(B BBBH4��(��`t��B�A�A �� GBGAAB��4��D(��8u��B�A�A �� GBGCAB��8��\|(��u��B�D�A �p ABF? FBI�8��(��w��B�D�A �~ DBEg AEC��`��(��z��z��B�B�B �B(�A0�D8�D@� 8F0A(B BBBF� 8C0A(B BBBDH��X)��$}��B�B�B �B(�A0�A8�FPX 8A0A(B BBBF4��)��x~��k��B�A�D �T CBAAFB��4��)��~��k��B�A�D �T CBAAFB��0����~��Q��A�A�G w AAFDCA�4��H��B�D�A �X DBKWAD��$����\|��O��Z�D�D fDB�4����B�D�A �X DBKWAD��@����B�D�D ^ DBJ] FBCD FBD�H��$+��B�B�B �B(�A0�A8�Dpx 8C0A(B BBBF�4��p+��j��B�A�D �O IGJqFB��4��+��D��c��B�A�D �S LGKbFB��8��+��\|��B�A�D �v FGFc FBE��,��4��0,��A�A�D � AAHD DAG��Pi��i�� W��(Z��+Z��.Z��1Z��3Z�� `�� =��o��`��p�� x��Q��(��)�� o��'��o��o��J&��o��_��x��6`��F`��V`��f`��v`��`��`��`��`��`��`��`��`��a��a��&a��6a��Fa��Va��fa��va��a��a��a��a��a��a��a��a��b��b��&b��6b��Fb��Vb��fb��vb��b��b��b��b��b��b��b��b��c��c��&c��6c��Fc��Vc��fc��vc��c��c��c��c��c��c��c��c��d��d��&d��6d��Fd��Vd��fd��vd��d��d��d��d��d��d��d��d��e��e��&e��6e��Fe��Ve��fe��ve��e��e��e��e��e��e��e��e��f��f��&f��6f��Ff��Vf��ff��vf��f��f��f��f��f��f��f��f��g��g��&g��6g��Fg��Vg��fg��vg��g��g��g��g��g��g��g��g��h��h��&h��6h��Fh��Vh��fh��vh��xmemstats() Print extra memory statistics. What is printed depends on the system configuration. ��The type of an object with special functionality that gives access to internals of the Python interpreter and thread structures. It is used as a top level root when traversing the heap to to make sure to find some special objects that may otherwise be hidden. There are no references from the RootState object to the special objects. But the heap traversal and related functions defined for RootStateType look into the Python interpreter and thread structures. The visibility is controlled by options set in the HeapView object which is passed to the traversal function. This makes it possible to hide an interpreter and/or some frames referring to system objects that should not be traversed. (See the attributes 'is_hiding_calling_interpreter' and 'limitframe' in HeapView.) The objects found in interpreter and thread structures are related to the RootState object via attributes with special names. These names have a special form which will be described below. The name starts with either an interpreter designator or a thread designator. It is then followed by the name of a member in the corresponding interpreter or thread structure. These names are the same as the names of the members in the C structures defining them. Some of the names may be dependent on the Python interpreter version used. The attribute names are used for two purposes: o To be the name used in the result of the 'relate' operation between the RootState object and some object that is referred to via an internal Python interpreter or thread structure. o To be used as attribute names when selecting objects from the RootState object. This may be used to get at such an object knowing only its attribute name. An attribute name is of one of the following three forms. i<interpreter number>_<interpreter attribute> i<interpreter number>_t<thread number>_<thread attribute> i<interpreter number>_t<thread number>_f<frame number> <interpreter number> The interpreter number identifies a particular interpreter structure. Often there is only one interpreter used, in which case the number is 0. It is possible to use more than one interpreter. The interpreters are then numbered from 0 and up in the order they were started. [This applies as long as no interpreter is terminated while there is still a newer interpreter running. Then the newer interpreters will be renumbered. If this is found to be a problem, a solution may be devised for a newer release.] <interpreter attribute> The interpreter attribute is a member with PyObject pointer type in the PyInterpreterState structure and can be, but not limited to, one of the following: modules sysdict builtins codec_search_path codec_search_cache codec_error_registry <thread number> The thread numbers are taken from the thread identity number assigned by Python. [ In older versions without thread identity numbers the hex address will be used.] <thread attribute> The thread attribute is a member with PyObject pointer type in the PyThreadState structure and can be, but not limited to, one of the following: c_profileobj c_traceobj curexc_type curexc_value curexc_traceback exc_type exc_value exc_traceback dict async_exc <frame number> The frame list is treated specially. The frame list is continually changed and the object that the frame member points to is not valid for long enough to be useful. Therefore frames are referred to by a special designator using the format shown above with a frame number. The frame number is the number of the frame starting from 0 but counting in the reversed order of the frame list. Thus the first started frame is 0, and in general the most recent frame has a number that is the number of frames it has before it in call order. ��NodeGraph([iterable [,is_mapping]]) Construct a new NodeGraph object. The arguments are: iterable An iterable object that will be used to initialize the new nodegraph. It should yield a sequence of edges of the form (source, target). is_mapping A boolean which, if True, will cause the nodegraph to be treated like a 'mapping'. It will then, for the purpose of indexing, be expected to contain a single target for each source node. A NodeGraph object contains pairs of nodes (edges) and can be indexed on the first node of the pair (the source of an edge) to find all second nodes of such pairs (the targets of those edges). NodeGraph objects are used internally in the heapy system, for example to record dict ownership and shortest-path graphs. They may be used generally for mapping and dict-like purposes, but differ in the following: o The mapping is based on object identity - no equality or hashing is assumed, so any object can be used as a key. Only the address is used. To distinguish this usage from that of ordinary dicts and sets, such objects are called 'nodes'. o There may be any number of targets associated with each source. o Performance characteristics differ from dicts, in somewhat subtle ways. ��NG.updated(X:iterable) -> NodeGraph Return a copy of NG updated with the edges from X, specified as pairs of the form (source, target).��NG.update(X:iterable) Update NG with the edges from X, specified as pairs of the form (source, target).��NG.relimg(X:iterable) -> NodeSet Return the relational image of NG wrt X. That is, the set of nodes that are the target of some edge that have its source in X.��NG.inverted() -> NodeGraph Return a copy of NG with the edges inverted.��NG.invert() Invert the edges of NG.��NG.get_range() -> NodeSet Return the set of nodes that are the target of some edge in NG.��NG.get_domain() -> NodeSet Return the set of nodes that are the source of some edge in NG.��NG.domain_restricted(X:iterable) -> NodeGraph Return a new NodeGraph, containing those edges in NG that have source in X.��NG.domain_covers(X:iterable) -> bool Return True if each node in X is the source of some edge in NG, False otherwise.��NG.copy() -> NodeGraph Return a copy of NG.��NG.clear() Remove all items from NG.��NG.as_flat_list() -> list Return the edges of NG in the form [src0, tgt0, src1, tgt1 ...].��NG.add_edges_n1(srcs:iterable, tgt) Add to NG, for each src in srcs, an edge from src to tgt.��NG.add_edge(source, target) Add to NG, an edge from source to target.��H.news(X:iterable) -> NodeSet Return the set of objects in X that is not in the set of objects of H. If H was created from the contents of the heap at a particular time, H.news(X) will return the set of objects in X that were allocated after H was created. ��Horizon(X:iterable) Create a new Horizon object from X. The objects in X will be used to initialize a set of objects within the Horizon object. There are no official references to these objects, but as some of these objects become deallocated, they will be removed from the set of objects within the Horizon object. The objects within the set of objects within the Horizon object can be compared to another set of objects via the news() method. This can be used to see what objects have been allocated but not deallocated since the Horizon object was created. ��C.select(X:iterable, kind:object, cmp:string) -> list Select objects of a particular kind. Each object in X is classified by C to get its kind and this is compared with the kind argument to determine if the object will be returned in the return list. The cmp argumt tells how the kind of the object OK is compared to the kind argument AK and can be one of < <= == != > >= . The comparison '<=' used depends on the classifier. Not all classifier may have such a comparison available. The common cases where it is available are: For the type classifier: A <= B means A is a subtype of B. For the size classifier: A <= B means that the size A is less or equal than B. For the referenced-by classifier: A <= B means that A is a subset of B. ��C.partition(X:iterable) -> dict Return a partition of a set of objects. Each object in X is classified by C to get its kind. The partition returned is a mapping from each different kind to a list containing the objects of that kind.��C.classify(object) -> object Return the kind of an object. The object is classified by C, to get its kind which is then returned.��This is the type of objects created by the hv_cli_* factory methods of HeapView objects. See HeapView.__doc__ and the factory methods for the different kinds of classifiers that are supported. ��HV.cli_indisize(memo) -> ObjectClassifier Return a classifier that classifies by "individual size". The classification of each object is an int, containing the object's individual memory size. The argument is: memo A dict used to memoize the classification objects.��This module contains low level functionality for the heapy system. It is intended to be wrapped in higher level library classes. Summary of module content. Classes HeapView Gives a parameterized view of the heap. Horizon Limits the view back to some moment in time. NodeGraph Graph of nodes (address-treated objects). ObjectClassifier Classifies objects on various criteria. RootStateType Root of heap traversal using Python internals. Functions interpreter Start a new interpreter. set_async_exc Raise an exception in another thread. xmemstats Print system-dependent memory statistics. Object RootState The single instance of RootStateType. ��X��"Y��X��X��X��X��Y��Y��Y��'Y��-Y��'Y��-Y��Z��Z��XT��fT��3Y��6V��5Y��7Y��BY��KY��PY��`Y��@��jY��{��hI��4U��P��ZU��X��eU��`��qU��h��~U��p��tU��@��T��U��U��U��U��jT��x��yT��T��t��T��T��T��T��T��x��T��T��T�� T�� U�� (U�� kV��I��X�� 0��8J��rY�� 1��J��Z��`��Z��Y��`k��`��V��`��Z��!��`��W��`��6Z�� k��`��_��kV�� L��AZ�� 8��xN��KY��@P��_Z��(��Q��0��Z��R��j��0��0��}Z��[��j��j��0��Z��[��P��Pr��0��B[��M[��@��"Y��X��0��W��R��@s��@��0��Z��S��@��r��0��0��B[��M[�� 0��f[��(S��r��0��sZ��PS��P��r��0��lZ��S��j��j��0��W��M[��p��`j��0��W��S��P��s��`i��i��i��YY��\|Y��Y��@��Y��Y��T��`��Y��@��Y��p��`��Y�� Y��Y�� `��Y��!��Y��@��Y�� Y��!�� Z��(��o��@��k��q��W��@��v��W��`�� s��W�� n��lZ��r��sZ��q��W�� W��0��l��}Z�� l��IW�� p��>W��0��`n��Z�� k��Z��@��l��V��w��Z��j��Z��j��bV��i��V�� h��Z��0��h��Z��e��Z��f��{V��d��Y��c��V��0��`��X��^��X��]��Z��\��pq��Pl��w��r[��i��D��`v��Pj��[�� p��@��l��j��l��0��#��`��S��h��`q��p��l��l��[��8��`��D��k��` ��`#��P��[�� 0u�� [��X��`��D��@x��p�� `�� T�� p��@��@k��l��`��@5��P<��4��`4��07��07��9��09��2��@/��6��@6��5��(��,��)����8��GCC: (GNU) 10.2.1 20210130 (Red Hat 10.2.1-11)��`i��pi�� i��,��i��>��i��M��i��\��i��k��i��V��z��Pj�� `j��(��j��j�� j��j��j��j�� k�� k��+��@k��8��`k��E��k��U��k��d��0l��x��Pl��3��l��l��l��1��l��1��0m��n��o��6��p��p�� `q��pq��,��+��q��;��Pr��-��U��r��e��r��S��r��I��@s��S��s��0u��#�� \��Pv��G����w��{��%�� 6��h��H��1��Q��o��`��m��@#��H#��8#��h��0��.��`��w��%��4��0��D��h��Y��@��i��P��~��#�� 0��@��P��P��u��.��#��?��p��Q��\��g��[��q�� "��}��P��s�� s��b�� `�� /�� p\���� P\��5��@��P��A��X��K��N��]��P��o��F��z��P��p��`��h�� h�� @��_��p��@����3��?��]��g��w��q��{��@��0�� 0��0�� 0��r��j��P��`��"����A��:��D��j��_��`��4��l��(��z��`��M��@��8��@��`��(�� 0�� 0��# ��0��. ��0��= �� I ��0��Y �� e ��0��u ��0�� `��0�� `��0�� 0�� `��0�� u�� 0�� `�� 0��- ��@��8 ��0��G ��4��S ��p��T��a ��-��l �� `�� 0��&�� `��]�� $�� p��P��i��-��{��8��@��J��C��N�� [��@��r��l��v��p��P��0�� $��!��!��Z��!�� h��@��@��c��@��`�� `#��(����P��1��` ��<��G��L��@��_��`��\��t��&��`��-��w��`��{��\��[��`��%��I��@�� i�� ' �� @��7 ��@ ��`��P��L ��X ��`��i ��`��{ ��`�� `��P�� _��J�� `�� v�� s��'�� n��0�� r�� q��"�� l��i��3�� l��C�� p��!��S�� `n��b�� k��r�� l�� w��g�� j��z�� j�� i��J�� h�� h�� e�� f��;�� d��I�� c��W�� `��i�� ^�� ]�� \��x��#�� +�� l�� `v��;�� @x��h��h��i��`!��!��H��Pi��T��s��(��)����,��@/��z��2��`4��k��4��k��@5��Q��5��@6��O��6��07��8��j��/��09��c��=��9��M��P<��Y��g�� t��x��}��8��`!��8��`��p��J&��'��(��Q�� `�� `��h��=�� @��8��@�� x��H��@��`!��@��,��0�� A��N��!��X��p!��h��v�� $��`�� -�� >��N��@��X��c��n��P��7��F��V��f��r��p��v�� 0�� =��A�� %��8��I�� Z��l��\|�� /��?��S��0$��u��a��o�� /�� p��)��F��T��g��x�� 1�� J�� "��0��D��S��b��!��r�� 0��e��m��@�� !��*��6��F��7��U��h��p��!��`��:��N��\��t�� 4��0�� S��)��@�� C��T��w�� /��P ��Y�� "��.��@��Q��^��q��px��p��E��1��@��P��e��u��X�� @ ��Z��z��!��.��;��P��d��u��@�� @��,��"�� `��H�� Z��e��p<��u��P ��P�� P��xt_error_size�xt_hd_relate�xt_error_relate�xt_error_traverse�xt_no_traverse�xt_tp_traverse�xt_he_traverse�nodetuple_hash�nodetuple_traverse�hv_cli_dictof_memoized_kind�hv_cli_id_classify�hv_cli_id_le�rel_traverse�hv_cli_none_classify�hv_cli_none_le�hv_cli_type_classify�hv_ne_rec�hv_get_limitframe�cli_traverse�cli_classify�ngiter_traverse�ng_gc_traverse�ng_compare_src_only�nodegraph_traverse�rootstate_gc_traverse�rootstate_new�cli_clear�rel_clear�hv_relate_visit�cli_partition_iter�ngiter_dealloc�cli_dealloc�rel_dealloc�rootstate_repr�nodegraph_size�ngiter_iternext�hv_cli_user_memoized_kind�hv_cli_idset_le�hv_cli_prod_memoized_kind�hv_cli_indisize_memoized_kind�hv_cli_findex_memoized_kind�hv_cli_and_memoized_kind�horizon_dealloc�rm�__func__.5�ng_sortetc�ng_compare�nodegraph_relate�rootstate_dir�rootstate_relate�rootstate_dealloc�rel_hash�xt_hd_traverse�hp_xmemstats�dlptr__PyObject_DebugMallocStats�dlptr_malloc_stats�dlptr__Py_RefTotal�hv_gc_traverse�nodetuple_richcompare�nodetuple_richcompare.cold�hv_cli_type_le�hv_set_limitframe�hv_default_size�hv_cli_prod_le�rel_richcompare�rel_richcompare.cold�hv_cli_inrel_le�hv_cli_user_classify�hv_delete_extra_type�hv_new_xt_for_type�rg_rec�xt_default_relate�hv_cli_rcs_le�hv_cli_indisize_le�hv_cli_findex_le�hv_cli_and_classify�xt_inherited_relate�hv_cli_prod_classify�sizeof_PyGC_Head�rootstate_getattr�is_members�ts_members�ng_length�hv_ss_visit�rcs_visit_memoize_sub�inrel_visit_memoize_relation�ng_get_range�ng_get_domain�iter_rec�horizon_update_trav�horizon_patched_dealloc�hv_update_static_types_visitor�__func__.1�__func__.0�hv_ra_rec_e�hv_ra_rec�horizon_news_trav�hv_cleanup_mutset�hv_cms_rec�hv_cli_idset_classify�hv_gc_clear�hv_dealloc�hv_extra_type.part.0�xt_error�default_hd�hv_indisize_sum_rec�hv_relimg_trav�hv_cli_indisize_classify�hv_register_hidden_exact_type�kwlist.9�hv_numedges�hv_register__hiding_tag__type�kwlist.10�hv_relate�kwlist.11�hv_shpath_outer�hv_shpath_inner�hv_shpathstep�kwlist.12�hv_reachable_x�kwlist.8�hv_reachable�kwlist.7�hv_heap_rec�hv_new�kwlist.13�rel_new�kwlist.3�hv_cli_inrel_visit�hv_heap�hv_indisize_sum�hv_relimg�hv_cli_inrel_memoized_kind�horizon_news�cli_partition�kwlist.2�hv_cli_rcs_memoized_kind�cli_select_kind�hv_cli_findex_classify�cmp_strings�cli_select�hv_cli_user_defined�kwlist.6�hv_cli_user_def�hv_cli_type�hv_cli_type_def�hv_cli_rcs�hv_cli_rcs_def�hv_cli_prod�hv_cli_prod_def�hv_cli_none�hv_cli_none_def�hv_cli_inrel�hv_cli_inrel_def�hv_cli_indisize�hv_cli_indisize_def�hv_cli_idset�hv_cli_idset_def�hv_cli_id�hv_cli_id_def�hv_cli_findex�hv_cli_findex_def�hv_cli_dictof�hv_cli_dictof_def�hv_cli_and�hv_cli_and_def�ng_gc_clear�urco_traverse�ng_dealloc�cli_epartition_iter�hv_cli_dictof_update�hv_cli_dictof_update_rec�ng_add_edges_n1_trav�ng_update_visit�ng_invert�hv_cli_rcs_classify�hv_cli_inrel_classify�hv_cli_dictof_classify�ng_relimg_trav�ng_dr_trav�ng_dc_trav�ng_ass_sub�ng_subscript�ng_domain_covers�ng_relimg�ng_domain_restricted�ng_new�kwlist.4�ng_update�ng_inverted�ng_updated�cli_epartition�moduledef�module_methods�hp_xmemstats_doc�rootstate_methods�ng_as_mapping�ng_members�ng_getset�ng_doc�ng_methods�ng_add_edge_doc�ng_add_edges_n1_doc�ng_as_flat_list_doc�ng_clear_doc�ng_copy_doc�ng_domain_covers_doc�ng_domain_restricted_doc�ng_get_domain_doc�ng_get_range_doc�ng_invert_doc�ng_inverted_doc�ng_relimg_doc�ng_update_doc�ng_updated_doc�horizon_methods�news_doc�cli_members�cli_methods�cli_classify_doc�cli_partition_doc�cli_select_doc�hv_getset�hv_limitframe_doc�hv_members�hv_methods�hv_cli_and_doc�hv_cli_dictof_doc�hv_cli_findex_doc�hv_cli_id_doc�hv_cli_idset_doc�hv_cli_indisize_doc�hv_cli_inrel_doc�hv_cli_none_doc�hv_cli_prod_doc�hv_cli_rcs_doc�hv_cli_type_doc�hv_cli_user_defined_doc�hv_delete_extra_type_doc�hv_indisize_sum_doc�hv_heap_doc�hv_numedges_doc�hv_reachable_doc�hv_reachable_x_doc�hv_register_hidden_exact_type_doc�hv_register__hiding_tag__type_doc�hv_relate_doc�hv_relimg_doc�hv_shpathstep_doc�hv_update_dictowners_doc�hv_update_referrers_doc�hv_update_referrers_completely_doc�rel_members�rel_methods�nodetuple_doc�hv_doc�deregister_tm_clones�__do_global_dtors_aux�completed.0�__do_global_dtors_aux_fini_array_entry�frame_dummy�__frame_dummy_init_array_entry�code_traverse�type_traverse�type_relate�code_relate�frame_relate�frame_traverse�tuple_relate�list_relate�dict_traverse�meth_relate�cell_relate�traceback_relate�set_relate�dictproxy_relate�module_relate�function_relate�dict_relate�__FRAME_END__�__dso_handle�_DYNAMIC�__GNU_EH_FRAME_HDR�__TMC_END__�_GLOBAL_OFFSET_TABLE_�PyUnicode_FromFormat�PyObject_SetItem�PyList_New�PyExc_SystemError�PySequence_Check�PyDict_SetItemString�NyNodeTuple_Type�NyNodeSet_NewImmCopy�PyThreadState_GetFrame�NyNodeGraph_New�_PyTrash_cond�horizon_new�PyModule_Type�abort@@GLIBC_2.2.5�PyExc_NotImplementedError�_ITM_deregisterTMCloneTable�NyNodeGraph_init�PyDictProxy_New�PyTuple_Type�NyNodeSet_be_immutable�PyList_AsTuple�NyMutNodeSet_New�xt_findout_size�hv_update_dictowners�PyMem_Free�qsort@@GLIBC_2.2.5�PyCapsule_GetName�NyRootState_Type�rootstate_doc�PyObject_GetAttrString�PyCell_Type�PyList_SetSlice�heapyc_doc�cli_cmp_as_int�hv_update_referrers�_Py_Dealloc�PyInterpreterState_Next�PyErr_NoMemory�PyErr_SetObject�PyObject_GC_Del�PyIter_Next�gc_get_objects�_Py_NotImplementedStruct�NyRelation_New�NyMutNodeSet_NewHiding�NyNodeSet_hasobj�PyObject_RichCompare�_fini�NyRelation_SubTypeNew�NyNodeGraph_Type�PyObject_GC_Track�PyExc_RuntimeError�_PySys_GetSizeOf�NyNodeSet_setobj�PyObject_SelfIter�PyErr_SetString�PyExc_UserWarning�PyMember_GetOne�NyHorizon_Type�_PyObject_GC_New�PyExc_ValueError�strrchr@@GLIBC_2.2.5�PyExc_DeprecationWarning�PyExc_TypeError�PyType_GenericNew�NyRelation_Type�PyTuple_GetItem�memset@@GLIBC_2.2.5�PyInit_heapyc�PyMem_Realloc�PyErr_ExceptionMatches�PyTraceBack_Type�PyCode_Type�PySequence_GetItem�_Py_FatalErrorFunc�NyNodeGraph_SubtypeNew�PySequence_GetSlice�NyHeapView_SubTypeNew�hv_update_referrers_completely�_PyWeakref_CallableProxyType�PyObject_Free�PyLong_FromSsize_t�PyCapsule_Import�NyNodeGraph_Invert�PyType_Ready�NyNodeGraph_Inverted�PyLong_FromLong�PyLong_AsSsize_t�PyObject_RichCompareBool�PyDict_GetItem�PySequence_Size�PyErr_Clear�ng_add_edges_n1�PyList_Append�strcmp@@GLIBC_2.2.5�PyExc_KeyError�_PyTrash_begin�nodeset_exports�fprintf@@GLIBC_2.2.5�_Py_FalseStruct�xt_findout_relate�__gmon_start__�ng_iter�PyTuple_New�ng_as_flat_list�PyObject_GenericGetAttr�PyThreadState_Get�NyNodeSet_iterate�_hiding_tag__name�PyType_Type�PySys_GetObject�dict_relate_kv�NyStdTypes_HeapDef�cli_doc�NyNodeSet_Type�PyErr_Occurred�PyModule_Create2�NyHeapView_Type�PyLong_AsLong�PyImport_ImportModule�PyList_SetItem�ng_clear_method�PyObject_CallFunctionObjArgs�PyTuple_SetItem�_PyObject_CallMethod_SizeT�NyNodeGraph_AddEdge�PyObject_Size�_PyArg_ParseTuple_SizeT�_Py_NoneStruct�sscanf@@GLIBC_2.2.5�PyObject_IsTrue�horizon_doc�PyType_GenericAlloc�hv_is_obj_hidden�PyObject_Hash�NyHeapView_iterate�_PyTraceMalloc_GetTraceback�xt_findout_traverse�NyImmNodeSet_NewSingleton�PyWeakref_NewRef�_PyArg_ParseTupleAndKeywords_SizeT�PyList_Size�_PyTrash_end�_Py_TrueStruct�NyNodeGraph_Update�NyNodeGraph_SiblingNew�PyFunction_Type�NyNodeGraph_Region�dlsym�PyDict_New�PyExc_IndexError�ng_copy�PyDict_Type�PyDict_Next�PyBaseObject_Type�PyUnicode_AsUTF8�PyFrame_Type�_PyWeakref_RefType�PyCapsule_Type�_PyObject_GetDictPtr�_PyObject_GC_NewVar�_PyObject_New�rootstate_traverse�NyObjectClassifier_Type�NyObjectClassifier_New�PyUnicode_FromString�PyObject_GetIter�PyExc_ImportError�PyDict_SetItem�PyFrame_GetBack�PyExc_AttributeError�PySequence_List�ng_add_edge�PyInterpreterState_Get�_PyWeakref_ProxyType�NyMutNodeSet_NewFlags�NyObjectClassifier_Compare�NyNodeGraph_Copy�PyErr_CheckSignals�xt_free_table�PyType_IsSubtype�PyTuple_Size�PyErr_Format�PyCapsule_GetPointer�fwrite@@GLIBC_2.2.5�PyModule_GetDict�NyNodeGraphIter_Type�PyFrozenSet_Type�_ITM_registerTMCloneTable�NyHvTypes_HeapDef�PyCFunction_Type�PyInterpreterState_Head�PyList_GetItem�PyObject_IS_GC�PyMem_Malloc�PyErr_WarnFormat�__cxa_finalize@@GLIBC_2.2.5�hv_mutnodeset_new�PySet_Type�NyStdTypes_init�_Ny_RootStateStruct�NyNodeSet_clrobj�PyObject_GC_UnTrack�NyNodeGraph_Clear�PyList_Type�stderr@@GLIBC_2.2.5��.symtab�.strtab�.shstrtab�.note.gnu.build-id�.gnu.hash�.dynsym�.dynstr�.gnu.version�.gnu.version_r�.rela.dyn�.rela.plt�.init�.text�.fini�.rodata�.eh_frame_hdr�.eh_frame�.init_array�.fini_array�.data.rel.ro�.dynamic�.got�.got.plt�.data�.bss�.comment��8��8��$��.��o��`��`��t��8��@��p��p�� H��o��J&��J&��U��o��'��'�� d��(��(��)��n��B��Q��Q��x��x��`��`��s�� `�� `��`��~��h��h��=��=�� @��@��6E�� 8��8��@��@��h,�� X�� x��x��H��H��@��@��@�� M�� `!��`��h�� 0��`��/��0��8�� PB��0b��	154.55 KB	2026-01-20 12:58
📄 pbhelp.py # AUTOMATICALLY GENERATED BY GENGUPPY about = b'\x80\x04\x95[\x02\x00\x00\x00\x00\x00\x00\x8c\x0eguppy.gsl.Text\x94\x8c\x0eRecordingInter\x94\x93\x94)\x81\x94}\x94(\x8c\x07appends\x94]\x94(K\x00\x8c\x16Heapy Profile Browser\n\x94K\x01\x8c\x01\t\x94K\x02\x8c\x07Version\x94K\x01h\x08K\x03\x8c\x040.1\n\x94K\x04h\x08K\x02\x8c\x06Author\x94K\x04h\x08K\x03\x8c\x10Sverker Nilsson\n\x94K\x04h\x08K\x02\x8c\x05Email\x94K\x04h\x08K\x03\x8c\x0bsn@sncs.se\n\x94K\x04h\x08K\x02\x8c\x07License\x94K\x04h\x08K\x03\x8c\x04MIT\n\x94K\x05\x8c\x18Copyright (c) 2005--2008\x94K\x06\x8c.S. Nilsson Computer System ABLinkoping, Sweden\x94K\x07\x8c\x01\n\x94e\x8c\x0btag_configs\x94}\x94(K\x00\x8c\x08spacing1\x94K\x0b\x86\x94\x8c\x04font\x94\x8c\x05times\x94K\x18\x8c\x04bold\x94\x87\x94\x86\x94\x86\x94K\x02h\x17h\x18h\x19K\x0c\x8c\x04bold\x94\x87\x94\x86\x94\x86\x94K\x03h\x17h\x18h\x19K\x0c\x86\x94\x86\x94\x86\x94K\x01\x8c\x04tabs\x94(G@A\x80\x00\x00\x00\x00\x00\x8c\x06center\x94G@T\x00\x00\x00\x00\x00\x00\x8c\x04left\x94t\x94\x86\x94h\x17h \x87\x94K\x04h)h\x16K\x06\x86\x94\x86\x94K\x05h+h\x18h\x19K\n\x8c\x06italic\x94\x87\x94\x86\x94\x86\x94K\x06h+h\x18h\x19K\n\x86\x94\x86\x94\x86\x94K\x07h+h#\x86\x94K\x08h#\x85\x94u\x8c\n_gsl_title\x94\x8c\x1bAbout Heapy Profile Browser\x94\x8c\x10_gsl_tk_geometry\x94\x8c\x07400x200\x94ub.' help = b'\x80\x04\x95v*\x00\x00\x00\x00\x00\x00\x8c\x0eguppy.gsl.Text\x94\x8c\x0eRecordingInter\x94\x93\x94)\x81\x94}\x94(\x8c\x07appends\x94]\x94(K\x00\x8c\x06Menus\n\x94K\x01\x8crClick on the dotted line at the top of a menu to "tear it off": a separate window containing the menu is created.\n\x94K\x03\x8c\nFile Menu\n\x94K\x05\x8c\x01\t\x94K\x06\x8c\x13New Profile Browser\x94K\x05h\nK\x07\x8c\x15Create a new browser\n\x94K\x08\x8c\x02\t\t\x94K\x07\x8c\x15window with the same\n\x94K\x08h\rK\x07\x8c\x10file as the one\n\x94K\x08h\rK\x07\x8c\x16opened in the current\n\x94K\x08h\rK\x07\x8c\twindow. \n\x94K\th\nK\x06\x8c\x0cOpen Profile\x94K\th\nK\x07\x8c\x14Open a profile data\n\x94K\x08h\rK\x07\x8c\x14file in the current\n\x94K\x08h\rK\x07\x8c\x13window. Data files\n\x94K\x08h\rK\x07\x8c\x14can be created with\n\x94K\x08h\rK\n\x8c\nStat.dump \x94K\x07\x8c\x03. \n\x94K\th\nK\x06\x8c\x0cClose Window\x94K\th\nK\x07\x8c\x12Close the current\n\x94K\x08h\rK\x07\x8c\x16window (exits from Tk\n\x94K\x08h\rK\x07\x8c\x13if it was the last\n\x94K\x08h\rK\x07\x8c\x12browser window). \n\x94K\th\nK\x06\x8c\x0bClear Cache\x94K\th\nK\x07\x8c\x11Clear the sample\n\x94K\x08h\rK\x07\x8c\x15cache, releasing its\n\x94K\x08h\rK\x07\x8c\x12memory. The cache\n\x94K\x08h\rK\x07\x8c\x16will be automatically\n\x94K\x08h\rK\x07\x8c\x12filled again when\n\x94K\x08h\rK\x07\x8c\tneeded. \n\x94K\x08h\rK\x0b\x8c\x11This command is a\x94K\x07\x8c\x01\n\x94K\x08h\rK\x0b\x8c\x13kind of temporary /\x94K\x07h&K\x08h\rK\x0b\x8c\x15experimental feature.\x94K\x07h&K\x08h\rK\x0b\x8c\x11I think the cache\x94K\x07h&K\x08h\rK\x0b\x8c\x12handling should be\x94K\x07h&K\x08h\rK\x0b\x8c\x12made automatic and\x94K\x07h&K\x08h\rK\x0b\x8c\x0bless memory\x94K\x07h&K\x08h\rK\x0b\x8c\x0bconsuming. \x94K\x07h&K\x03\x8c\nPane Menu\n\x94K\x0ch\nK\x06\x8c\x12Show Control Panel\x94K\x0ch\nK\x07\x8c\x17Show the control panel\n\x94K\rh\rK\x07\x8c\x07pane. \n\x94K\x0eh\nK\x06\x8c\nShow Graph\x94K\x0eh\nK\x07\x8c\x15Show the graph pane.\n\x94K\x0eh\nK\x06\x8c\nShow Table\x94K\x0eh\nK\x07\x8c\x15Show the table pane.\n\x94K\x03\x8c\x0bGraph Menu\n\x94K\x0fh\nK\x06\x8c\x0cBars / Lines\x94K\x0fh\nK\x07\x8c\x19Choose whether the graph\n\x94K\x10h\rK\x07\x8c\x1ashould be displayed using\n\x94K\x10h\rK\x07\x8c\x10bars or lines. \n\x94K\x10h\rK\x0b\x8c\x1bWhen using bars, the sample\x94K\x07h&K\x10h\rK\x0b\x8c\x19value (size or count) for\x94K\x07h&K\x10h\rK\x0b\x8c\x1adifferent kinds of objects\x94K\x07h&K\x10h\rK\x0b\x8c\x19will be stacked on top of\x94K\x07h&K\x10h\rK\x0b\x8c\x17each other so the total\x94K\x07h&K\x10h\rK\x0b\x8c\x1bheight represents the total\x94K\x07h&K\x10h\rK\x0b\x8c\x17value of a sample. When\x94K\x07h&K\x10h\rK\x0b\x8c\x16using lines, each line\x94K\x07h&K\x10h\rK\x0b\x8c\x1arepresents the value for a\x94K\x07h&K\x10h\rK\x0b\x8c\x1asingle kind of object. The\x94K\x07h&K\x10h\rK\x0b\x8c\x1b10 largest values are shown\x94K\x07h&K\x10h\rK\x0b\x8c\x1ain each sample point. Each\x94K\x07h&K\x10h\rK\x0b\x8c\x1ckind has a particular color,\x94K\x07h&K\x10h\rK\x0b\x8c\x1bchoosen arbitrary but it is\x94K\x07h&K\x10h\rK\x0b\x8c\x19always the same color for\x94K\x07h&K\x10h\rK\x0b\x8c\x1athe same kind. The remaing\x94K\x07h&K\x10h\rK\x0b\x8c\x1bkinds, if any, are shown in\x94K\x07h&K\x10h\rK\x0b\x8c\x07black. \x94K\x07h&K\x11h\nK\x06\x8c\x0cSize / Count\x94K\x11h\nK\x07h8K\x10h\rK\x07\x8c\x1bshould display the size of\n\x94K\x10h\rK\x07\x8c\x1dobjects of a particular kind\n\x94K\x10h\rK\x07\x8c\x1cor the number of objects of\n\x94K\x10h\rK\x07\x8c\x0cthat kind. \n\x94K\x10h\rK\x12\x8c\'(Note that this affects only the graph,\x94K\x07h&K\x10h\rK\x12\x8c(the table will still choose size or kind\x94K\x07h&K\x10h\rK\x12\x8c\'as it were choosen in the table menu.) \x94K\x07h&K\x03\x8c\x0bTable Menu\n\x94K\x13\x8c\x0fHeader submenu\n\x94K\x14XT\x01\x00\x00This menu has a choice of header for each column of the table. The data of each column is determined by the header of that column, as well as the headers of previous columns. So if you change the first column header (A/B), the data in that column will change as well as the data under the next header (Size/Count) and the ones that follow.\n\x94K\x15h\nK\x16\x8c\x05A / B\x94K\x15h\nK\x17\x8c\x18Use the sample at the A\n\x94K\x18h\rK\x17\x8c\x1aor B marker in the graph.\n\x94K\x18h\rK\x17h&K\x18h\rK\x14\x8c\x14The kinds of objects\x94K\x17h&K\x18h\rK\x14\x8c\x18shown in the table under\x94K\x17h&K\x18h\rK\x14\x8c\x15this column are taken\x94K\x17h&K\x18h\rK\x14\x8c\x13from the 10 largest\x94K\x17h&K\x18h\rK\x14\x8c\x15sample values at that\x94K\x17h&K\x18h\rK\x14\x8c\x18point, in the same order\x94K\x17h&K\x18h\rK\x14\x8c\x18as they are shown in the\x94K\x17h&K\x18h\rK\x14\x8c\x16graph. The ordering in\x94K\x17h&K\x18h\rK\x14\x8c\x18the graph depends on the\x94K\x17h&K\x18h\rK\x14\x8c\x17choice of count or size\x94K\x17h&K\x18h\rK\x14\x8c\x12in the graph menu.\x94K\x17h&K\x18h\rK\x14\x8c\x16However, the table may\x94K\x17h&K\x18h\rK\x14\x8c\x12show count or size\x94K\x17h&K\x18h\rK\x14\x8c\x14independent from the\x94K\x17h&K\x18h\rK\x14\x8c\x15choice in the graph. \x94K\x17h&K\x19h\nK\x16hMK\x19h\nK\x17\x8c\x1aShow the size or count of\n\x94K\x18h\rK\x17\x8c\x18the kinds of objects in\n\x94K\x18h\rK\x17\x8c\x15each row, taken from\n\x94K\x18h\rK\x17\x8c\x19those choosen in the A /\n\x94K\x18h\rK\x17\x8c\x0bB column. \n\x94K\x19h\nK\x16\x8c\x0f%A:Tot / %B:Tot\x94K\x19h\nK\x17\x8c\x17Show percentage of the\n\x94K\x18h\rK\x17\x8c\x15Size / Count column,\n\x94K\x18h\rK\x17\x8c\x16relative to the total\n\x94K\x18h\rK\x17\x8c\x1a(size or count) at either\n\x94K\x18h\rK\x17\x8c\x1athe A or B sample point. \n\x94K\x19h\nK\x1a\x8c\x07Cumul /\x94K\x19h\nK\x17\x8c\x19Show either a cumulative\n\x94K\x18h\nK\x1a\x8c\x00\x94K\x1b\x8c\tA-B / B-A\x94K\x18h\nK\x17\x8c\x18sum of the Size / Count\n\x94K\x18h\rK\x17\x8c\x1acolumn, or the difference\n\x94K\x18h\rK\x17\x8c\rA-B or B-A. \n\x94K\x18h\rK\x14\x8c\x15The cumulative sum is\x94K\x17h&K\x18h\rK\x14\x8c\x19taken by summing from the\x94K\x17h&K\x18h\rK\x14\x8c\x17first table row down to\x94K\x17h&K\x18h\rK\x14\x8c\x0ethe last row. \x94K\x17h&K\x19h\nK\x16hoK\x19h\nK\x17hpK\x18h\rK\x17\x8c\x19previous field, relative\n\x94K\x18h\rK\x17\x8c\x15to either the A or B\n\x94K\x18h\rK\x17\x8c\x08total. \n\x94K\x19h\nK\x16\x8c\x04Kind\x94K\x19h\nK\x17\x8c\x12Shows the kind of\n\x94K\x18h\rK\x17\x8c\x11objects. This is\n\x94K\x18h\rK\x17\x8c\x13currently the only\n\x94K\x18h\rK\x17\x8c\x15alternative for this\n\x94K\x18h\rK\x17\x8c\x17column. The kind shown\n\x94K\x18h\rK\x17\x8c\x19corresponds to the color\n\x94K\x18h\rK\x17\x8c\x13shown in the A / B\n\x94K\x18h\rK\x17\x8c\x1acolumn. A special kind is\n\x94K\x18h\rK\x17\x8c\x19<Other> which summarizes\n\x94K\x18h\rK\x17\x8c\x16the remaining data if\n\x94K\x18h\rK\x17\x8c\x18there were more than 10\n\x94K\x18h\rK\x17\x8c\x17different kinds in the\n\x94K\x18h\rK\x17\x8c\tsample. \n\x94K\x13\x8c\x12Scrollbar submenu\n\x94K\x15h\nK\x16\x8c\x0fAuto / On / Off\x94K\x15h\nK\x17\x8c\x19Choose a scrollbar mode.\n\x94K\x18h\rK\x17\x8c\x1aThe usual setting is Auto\n\x94K\x18h\rK\x17\x8c\x1awhich shows the scrollbar\n\x94K\x18h\rK\x17\x8c\x13only when needed. \n\x94K\x03\x8c\x0cWindow Menu\n\x94K\x0b\x8cqThis menu lists the names of all open windows. Selecting one brings it to the top, deiconifying it if necessary.\n\x94K\x03\x8c\nHelp Menu\n\x94K\x1ch\nK\x06\x8c\x05About\x94K\x1ch\nK\x07\x8c#Version, author, email, copyright.\n\x94K\x1dh\nK\x06\x8c\x04Help\x94K\x1dh\nK\x07\x8c\x17Open this help window.\n\x94K\x00\x8c\x06Panes\n\x94K\x01\x8c\x98There are 3 panes in the main window shown by default. At the top is the Control Panel, at the bottom left the Graph and at the bottom right the Table.\n\x94K\x03\x8c\x13Control Panel Pane\n\x94K\x1e\x8clThis contains controls for the graph and the markers. It also has a quick-exit button and a collect button.\n\x94K\x13\x8c\x13X / Y axis control\n\x94K\x14\x8c\xecThe two frames in the Control Panel having an X or Y button in the top left corner control each axis of the graph. The X, horizontal, axis shows the sample point. The Y axis shows either the size or count, as choosen in the Graph menu.\n\x94K\x1fh\nK\x16\x8c\x0cX / Y Button\x94K\x1fh\nK\x17\x8c\x1cBrings up a menu, currently\n\x94K h\rK\x17\x8c\x18containing some buttons\n\x94K h\rK\x17\x8c\x1athat can also be accessed\n\x94K h\rK\x17\x8c\x18directly in the panel. \n\x94K!h\nK\x16\x8c\x0bGrid button\x94K!h\nK\x17\x8c\x1bSelect if the graph should\n\x94K h\rK\x17\x8c\x12show grid lines. \n\x94K!h\nK\x16\x8c\rRange buttons\x94K!h\nK\x17\x8c\x19Change the range that is\n\x94K h\nK\x16hwK\x1b\x8c\x05- / +\x94K h\nK\x17\x8c\x17shown in the displayed\n\x94K h\rK\x17\x8c\x1aportion of the graph. For\n\x94K h\rK\x17\x8c\x1ceach time + or - is pressed\n\x94K h\rK\x17\x8c\x1athe range will be stepped\n\x94K h\rK\x17\x8c\x1bup or down in the sequence\n\x94K h\rK\x17\x8c\x18(1, 2, 5) and multiples\n\x94K h\rK\x17\x8c\x0bthereoff. \n\x94K!h\nK\x16\x8c\x0bRange field\x94K!h\nK\x17\x8c\x1bThe current range is shown\n\x94K h\rK\x17\x8c\x1ahere, and a new range can\n\x94K h\rK\x17\x8c\x19be entered by writing to\n\x94K h\rK\x17\x8c\x18this field and pressing\n\x94K h\rK\x17\x8c\x18Enter. The format is an\n\x94K h\rK\x17\x8c\x14integer that may be\n\x94K h\rK\x17\x8c\x1afollowed by a multiplier,\n\x94K h\rK\x17\x8c\x1cK, M, G, or T, meaning that\n\x94K h\rK\x17\x8c\x1athe value is multipled by\n\x94K h\rK\x17\x8c\x181000, 1E6, 1E9, or 1E12\n\x94K h\rK\x17\x8c\x1arespectively. The maximum\n\x94K h\rK\x17\x8c\x0erange is 1T. \n\x94K\x13\x8c\x15A / B sample control\n\x94K\x14\x8c\x95Each of the frames showing A or B in the top left corner controls one of the sample markers. The current position is shown in the bottom left corner.\x94K"\x8c\x86(This is currently not an entry field - TODO - but the marker may be moved long distances by directly dragging it in the Graph frame.)\x94K\x14h&K#h\nK\x16h\xaeK#h\nK\x17\x8c\x1cStep the marker one step to\n\x94K$h\rK\x17\x8c\x1dthe left (-) or to the right\n\x94K$h\rK\x17\x8c\x06(+). \n\x94K$h\rK\x14\x8c\x1cThe table will be updated to\x94K\x17h&K$h\rK\x14\x8c\x1bshow new data if it was set\x94K\x17h&K$h\rK\x14\x8c\x1bto show such data that were\x94K\x17h&K$h\rK\x14\x8c\x17dependent on the marker\x94K\x17h&K$h\rK\x14\x8c\x07moved. \x94K\x17h&K$h\rK\x14\x8c\x1bThe graph will show the new\x94K\x17h&K$h\rK\x14\x8c\x17marker position. If the\x94K\x17h&K$h\rK\x14\x8c\x19marker was outside of the\x94K\x17h&K$h\rK\x14\x8c\x18displayed portion of the\x94K\x17h&K$h\rK\x14\x8c\x1cgraph, the graph will scroll\x94K\x17h&K$h\rK\x14\x8c\x15so the marker becomes\x94K\x17h&K$h\rK\x14\x8c\tvisible. \x94K\x17h&K%h\nK\x16\x8c\x0cTrack button\x94K%h\nK\x17\x8c\x1bPress to set the marker to\n\x94K$h\rK\x17\x8c\x1cthe last sample in the file\n\x94K$h\rK\x17\x8c\x1band stay at the end as new\n\x94K$h\rK\x17\x8c\x18samples are added. (New\n\x94K$h\rK\x17\x8c\x19samples are periodically\n\x94K$h\rK\x17\x8c\x19read from the end of the\n\x94K$h\rK\x17\x8c\x1afile when auto-collect is\n\x94K$h\rK\x17\x8c\x19selected via the Collect\n\x94K$h\rK\x17\x8c\nbutton.) \n\x94K$h\rK\x14\x8c\x1bTracking is turned off when\x94K\x17h&K$h\rK\x14\x8c\x16the marker is manually\x94K\x17h&K$h\rK\x14h\xcdK\x17h&K\x13\x8c\x0cExit button\n\x94K\x14\x8cEExits the program, a shortcut for the Exit command in the File menu.\n\x94K\x13\x8c\x0fCollect button\n\x94K\x14\x8cvWhen selected, the browser will collect new samples from the current file, and will continue to do this periodically.\n\x94K"\x8c<Currently it will check the file for new data once a second.\x94K\x14h&K\x03\x8c\x0bGraph Pane\n\x94K\x0bX\x06\x01\x00\x00This pane shows the currently visible portion of the sample file. It can be scrolled via an horizontal scrollbar. The two markers are shown as buttons labeled A and B above the graph and with lines extending down in the graph. Markers can be moved by the mouse.\n\x94K\x07\x8ctHow to move the markers is hopefully quite self evident when tried out but I wrote up some details about it anyway.\n\x94K\x13\x8c\x18Marker movement details\n\x94K&X\x9d\x04\x00\x00Holding down the mouse button and moving the mouse moves the underlying marker. Klicking the mouse button over a marker without moving the mouse, selects the marker. While it is selected any movement of the mouse within the graph will move the marker with it. Klicking again anywhere in the graph will deselect the marker. If the marker can be moved, the cursor will be an arrow indicating the direction it can be moved, left or right or both. If the marker can not be moved in any direction, the cursor will show a circle or disc. The marker can not move outside the available samples. Moving the mouse outside of the graph also restricts the movement of the mouse, even if the mouse button is pressed. This is intentional so that the marker can be moved longer distances than the mouse can move. Moving the mouse to the right of the graph, the marker can only be moved to the right - moving back the mouse will not move the marker back until the mouse enters the graph area again. Similarly for the left side. Above or below the graph, the mouse will not move the marker at all but will show a circle to indicate that the mouse may be \'recirculated\' to move back into the graph.\n\x94K\x03\x8c\x0bTable Pane\n\x94K\x0b\x8c\x7fThis pane shows a table based on the configuration set in the Table menu. The sample number and time stamp show in the header.\n\x94e\x8c\x0btag_configs\x94}\x94(K\x00\x8c\x08spacing1\x94K\n\x86\x94\x8c\x04font\x94\x8c\x05times\x94K\x14\x8c\x04bold\x94\x87\x94\x86\x94\x86\x94K\x01h\xf0h\xf1h\xf2K\x0c\x86\x94\x86\x94\x86\x94K\x02h\xefK\x06\x86\x94h\xf8\x86\x94K\x03h\xefK\t\x86\x94h\xf1h\xf2K\x10\x8c\x04bold\x94\x87\x94\x86\x94\x86\x94K\x04h\xf8\x85\x94K\x06(\x8c\x08lmargin1\x94K$\x86\x94\x8c\x08lmargin2\x94K$\x86\x94h\xfah\xf1h\xf2K\x0c\x8c\x04bold\x94\x87\x94\x86\x94t\x94K\x07(j\x03\x01\x00\x00j\x05\x01\x00\x00h\xfah\xf8t\x94K\x05(\x8c\x04tabs\x94(G@``\x00\x00\x00\x00\x00\x8c\x06center\x94G@m\x80\x00\x00\x00\x00\x00\x8c\x04left\x94t\x94\x86\x94j\x03\x01\x00\x00j\x05\x01\x00\x00h\xfaj\x08\x01\x00\x00t\x94K\x08j\x0f\x01\x00\x00\x85\x94K\tj\x0f\x01\x00\x00h\xfa\x86\x94K\n(j\x03\x01\x00\x00j\x05\x01\x00\x00h\xfah\xf1h\xf2K\x0c\x8c\x06italic\x94\x87\x94\x86\x94t\x94K\x0bj\x03\x01\x00\x00j\x05\x01\x00\x00h\xf8\x87\x94K\x0c(j\x0b\x01\x00\x00(G@_\x80\x00\x00\x00\x00\x00j\x0c\x01\x00\x00G@l@\x00\x00\x00\x00\x00j\r\x01\x00\x00t\x94\x86\x94j\x03\x01\x00\x00j\x05\x01\x00\x00h\xfaj\x08\x01\x00\x00t\x94K\rj\x19\x01\x00\x00\x85\x94K\x0ej\x19\x01\x00\x00h\xfa\x86\x94K\x0f(j\x0b\x01\x00\x00(G@X\x00\x00\x00\x00\x00\x00j\x0c\x01\x00\x00G@d\xc0\x00\x00\x00\x00\x00j\r\x01\x00\x00t\x94\x86\x94j\x03\x01\x00\x00j\x05\x01\x00\x00h\xfaj\x08\x01\x00\x00t\x94K\x10j\x1e\x01\x00\x00\x85\x94K\x11j\x1e\x01\x00\x00h\xfa\x86\x94K\x12j\x03\x01\x00\x00j\x05\x01\x00\x00h\xf1h\xf2K\n\x86\x94\x86\x94\x87\x94K\x13(j\x03\x01\x00\x00j\x05\x01\x00\x00h\xefK\x08\x86\x94j\x08\x01\x00\x00t\x94K\x16(j\x02\x01\x00\x00KH\x86\x94j\x04\x01\x00\x00KH\x86\x94h\xfaj\x08\x01\x00\x00t\x94K\x17(j\'\x01\x00\x00j(\x01\x00\x00h\xfah\xf8t\x94K\x15(j\x0b\x01\x00\x00(G@b`\x00\x00\x00\x00\x00j\x0c\x01\x00\x00G@m\x00\x00\x00\x00\x00\x00j\r\x01\x00\x00t\x94\x86\x94j\'\x01\x00\x00j(\x01\x00\x00h\xfaj\x08\x01\x00\x00t\x94K\x18j,\x01\x00\x00\x85\x94K\x14j\'\x01\x00\x00j(\x01\x00\x00h\xf8\x87\x94K\x19j,\x01\x00\x00h\xfa\x86\x94K\x1aj)\x01\x00\x00K\x1bj\'\x01\x00\x00j(\x01\x00\x00j\x08\x01\x00\x00\x87\x94K\x1c(j\x0b\x01\x00\x00(G@N\x80\x00\x00\x00\x00\x00j\x0c\x01\x00\x00G@X\x00\x00\x00\x00\x00\x00j\r\x01\x00\x00t\x94\x86\x94j\x03\x01\x00\x00j\x05\x01\x00\x00h\xfaj\x08\x01\x00\x00t\x94K\x1dj3\x01\x00\x00h\xfa\x86\x94K\x1eh\xfch\xf8\x86\x94K\x1f(j\x0b\x01\x00\x00(G@a \x00\x00\x00\x00\x00j\x0c\x01\x00\x00G@j\x80\x00\x00\x00\x00\x00j\r\x01\x00\x00t\x94\x86\x94j\'\x01\x00\x00j(\x01\x00\x00h\xfaj\x08\x01\x00\x00t\x94K j8\x01\x00\x00\x85\x94K!j8\x01\x00\x00h\xfa\x86\x94K"j\'\x01\x00\x00j(\x01\x00\x00j#\x01\x00\x00\x87\x94K#(j\x0b\x01\x00\x00(G@`\x80\x00\x00\x00\x00\x00j\x0c\x01\x00\x00G@i@\x00\x00\x00\x00\x00j\r\x01\x00\x00t\x94\x86\x94j\'\x01\x00\x00j(\x01\x00\x00h\xfaj\x08\x01\x00\x00t\x94K$j>\x01\x00\x00\x85\x94K%j>\x01\x00\x00h\xfa\x86\x94K&(j\x03\x01\x00\x00j\x05\x01\x00\x00j%\x01\x00\x00h\xf8t\x94u\x8c\n_gsl_title\x94\x8c\x1eHelp for Heapy Profile Browser\x94ub.'	17.4 KB	2026-01-20 12:58
📁 test	-	2026-03-21 15:45

Edit File:

Terminal