ÿØÿàJFIFÿþ ÿÛC       ÿÛC ÿÀÿÄÿÄ"#QrÿÄÿÄ&1!A"2qQaáÿÚ ?Øy,æ/3JæݹÈ߲؋5êXw²±ÉyˆR”¾I0ó2—PI¾IÌÚiMö¯–þrìN&"KgX:Šíµ•nTJnLK„…@!‰-ý ùúmë;ºgµŒ&ó±hw’¯Õ@”Ü— 9ñ-ë.²1<yà‚¹ïQÐU„ہ?.’¦èûbß±©Ö«Âw*VŒ) `$‰bØԟ’ëXÖ-ËTÜíGÚ3ð«g Ÿ§¯—Jx„–’U/ÂÅv_s(Hÿ@TñJÑãõçn­‚!ÈgfbÓc­:él[ðQe 9ÀPLbÃãCµm[5¿ç'ªjglå‡Ûí_§Úõl-;"PkÞÞÁQâ¼_Ñ^¢SŸx?"¸¦ùY騐ÒOÈ q’`~~ÚtËU¹CڒêV  I1Áß_ÿÙ ;Pc@s/ddlZdejjjfdYZdS(iNt _GLUECLAMP_cBsveZdtZduZdvZdwZd/Zd0Zd1Zd2Z d3Z d4Z d5Z d6Z e Zd7d8Zd9Zd:d;Zd:d<d:d=Zd>Zd<d?Zd@ZdAZdBZdxdxdCZdxdDZdxdEZdxd:dFZedGZdyZddZ deZ!dfZ"dgZ#dhZ$diZ%djZ&dkZ'dlZ(dmZ)dnZ*doZ+dpZ,dqZ-drZ.dsZ/RS(zt _hiding_tag_treprefixtdefault_reprefixtgcobjstrelheaptrelheapgtrelheaput__doc__tAnythingtClasstClodotIdtIdsettModuletNothingtRcstRoottSizetTypetUnitytViatdoctfindextheaptheaputidsettisotloadtmonitortpbtsetrefttesttViewt _load_stattctimetdumphtheapgtloadct setrelheapt setrelheapgt setrelheaputtc_adaptttc_reprtuniontuniset_from_setcsatabletwarningstStatshpy().cCs|jS(N(R(tself((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt _get_gcobjsscCs|jS(N(R(R0((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt _get_relheapscCs|jS(N(R(R0((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt _get_relheapgscCs|jS(N(R(R0((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt _get_relheapu"scCshddl}xR|jjD]A\}}t||jrt|dd|jkrd|SqW|jS(Nit_shares%s.( t__main__t__dict__titemst isinstancet __class__tgetattrtNoneR5R(R0R6tktv((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt _get_reprefix%s   cCs |jjjS(sMRoot: 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(R!theapyct RootState(R0((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt _get_Root1s cCsd|j|jd fS(Ns@Top level interface to Heapy. Use eg: %sdoc for more info on %s.i(R(R0((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt__repr__>stcCs"|}|jjjjj||S(s= #OBSOLETE $HP.dir(opts: str+])-> GuppyDir $HP.dir(opts: str+]). -> 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.(t_roottguppytetctHelptdir(R0toptstobj((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pytDdirGscCs,|jjjjj|dddd|jS(sOverview 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.doctheaders3Top level interface to Heapy. Available attributes:tfooters2Use eg: %sdoc. for info on .(RERFRGRHRIR(R0((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt_get_doc]sicCs3|jjd|jj|}||j8}|S(s DEPRECATED sIMethod Use.heapg is depreciated, it doesn't work well. Use heapu instead.(R.twarnR!R%R(R0trmath((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR%{s   icCs|jj|}d}| rV|jrVt|jt|rV||j8}d}n|r|j}| r|jrt|jt|r||j8}d}nd|_|r|jd|j|jj7_n|jd7_n|S(sheapu() -> 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.setrefiisData from unreachable objectss relative to: %ss. ( R!RRR9ttypetstatt firstheaderR#ttimemade(R0RQtabsRTRRtrel((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyRs (   (    cCs-|jj}||jO}||j8}|S(sheap() -> 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(R!RRR(R0RR((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyRs  c sttr-tfd}ntdr^td r^fd}ntdr |rj}n j}g|}|stnd|}y=x6|rj|||krPn|}qWtWntk r j|nXfd}n tdt |j}|j ds]t d n||j d d j }yt||}Wn$tk rt d |fnX||S( sload(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.loadc3sEd}x8j|j}|s,Pnj}|Vq WdS(Ni(tseektreadlinettell(tpostline(tf(sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt get_trowss   t__iter__tnextcsS(N(((tfn(sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR_ss.end: %scsS(N(((ttrows(sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR_ssBArgument should be a string, file or an iterable yielding strings.s.loader:s1Format error in %r: no initial .loader directive.t:is'Format error in %r: no such loader: %r.(R9t basestringtopenthasattrRZRat StopIterationtappendt TypeErrortitert startswitht ValueErrortindextstripR;tAttributeError( R0Rbt use_readlineR_tget_lineR]tendlinetatloader((R^RbRcsB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyRsD                ccs=t|trt|}nxtr8|j|Vq!WdS(s< Generates all objects from an open file f or a file named fN(R9ReRftTrueR(R0R^((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pytloadall"s cCs1t|dd}x|j|ddGHqWdS(NtriRq(RfR(R0RbR^((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR&)scCs]t|d}ddl}x;|j}|jj||jt|jGHqWdS(Ntwi(RftgcRRTtdumptflushtlent get_objects(R0RbR^Rztx((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR$.s   cCsk|dkr/|dkr/|j|jn8|dk rK|j|n|dk rg|j|ndS(ssetref() 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.heapuN(R<R'R)(R0t reachablet unreachable((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR7s    cCs+|dkr|jj}n||_dS(N(R<R!RR(R0t reference((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR'Os cCsD|jjd|dkr7d|_|jj}n||_dS(Ns:Method Use.setrelheapg is depreciated, use setref instead.(R.RPR<RR!R%(R0R((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR(Ts    cCsb|dkr0d|_|jdtd|}n|rUt||j rU|j}n||_dS(NRWRT(R<RRRvR9R/RT(R0RRT((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR)\s    cCs|jjjj|dS(stest([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.N(t_parentR ttest_allt test_main(R0tdebug((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR ds s_parent.Classifiers:Classs_parent.Classifiers:Clodos_parent.Classifiers:Ids_parent.Classifiers:Idsets_parent.Classifiers:Modules_parent.Classifiers:Rcss_parent.Classifiers:Sizes_parent.Classifiers:Types_parent.Classifiers:Unitys_parent.Classifiers:Vias_parent.Classifiers:findexs_parent.Classifiers:sonokinds_parent.Classifiers:tc_adapts_parent.Classifiers:tc_reprs_parent.Monitor:monitors_parent.Part:_load_stats_parent.Part:Stats_parent.Prof:pbs_parent.UniSet:Anythings_parent.UniSet:idsets_parent.UniSet:isos_parent.UniSet:Nothings_parent.UniSet:unions&_parent.UniSet:uniset_from_setcastables _parent:Views_parent.View:_hiding_tag_s_root.time:ctimes_root:warningssAnything: Kind A symbolic set that represents all possible Python objects. References [0] heapy_Use.html#heapykinds.Use.AnythingsrClass:EquivalenceRelation Class(tc:typeorclass+) -> Kind Equivalence relation by class. It defines objects to be equivalent when their builtin __class__ attributes are identical. When called it returns the equivalenc class defined by the argument: tc: A type or class that the returned kind should represent. References [0] heapy_Use.html#heapykinds.Use.ClasssClodo:EquivalenceRelation Clodo(alt:[tc: typeorclassexceptdict+ or dictof = typeorclassoremptytuple+]) -> Kind Equivalence relation by class or dict owner. It distinguishes between objects based on their class just like the Class 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 or class 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 or class 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.ClodosYId: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.IdsId: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.sModule: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.Modules^Nothing: IdentitySet The empty set. References [0] heapy_Use.html#heapykinds.Use.NothingsRcs: 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.Rcss?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.KindOfSizeFamilysType: 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.KindOfTypeFamilys?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.AnythingsVia: 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.KindOfInViaFamilys~ 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.EquivalenceRelationsqidset(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.IdentitySetsuiso( 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.idsett (R(RRRRRRR(R R R R R RRRRRRRRRRRRRRRRRRR (R!RR"R#RR$RR%R&RRRRR'R(R)R*R+R,R-R.R/N(s_parent.Classifiers:Classs_parent.Classifiers:Clodos_parent.Classifiers:Ids_parent.Classifiers:Idsets_parent.Classifiers:Modules_parent.Classifiers:Rcss_parent.Classifiers:Sizes_parent.Classifiers:Types_parent.Classifiers:Unitys_parent.Classifiers:Vias_parent.Classifiers:findexs_parent.Classifiers:sonokinds_parent.Classifiers:tc_adapts_parent.Classifiers:tc_reprs_parent.Monitor:monitors_parent.Part:_load_stats_parent.Part:Stats_parent.Prof:pbs_parent.UniSet:Anythings_parent.UniSet:idsets_parent.UniSet:isos_parent.UniSet:Nothings_parent.UniSet:unions&_parent.UniSet:uniset_from_setcastables _parent:Views_parent.View:_hiding_tag_s_root.time:ctimes_root:warnings(0t__name__t __module__t _preload_t _chgable_t_dir_t _private_RR1R2R3R4R?RBRCt__str__RLROR%RRRRwR&R$R<RR'R(R)tFalseR t _imports_t _doc_Anythingt _doc_Classt _doc_Clodot_doc_Idt _doc_Idsett _doc_Modulet _doc_Nothingt_doc_Rcst _doc_Sizet _doc_Typet _doc_Unityt_doc_Viat _doc_findext _doc_idsett_doc_isot _doc_sokind(((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyRs        (  a          '%(tguppy.etc.GlueRFRGtGluet InterfaceR(((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyts